Move shell completion generation into 'kubectl completion' command

build/common.sh

@@ -478,7 +478,6 @@ function kube::build::source_targets() {
     test
     third_party
     vendor
-    contrib/completions/bash/kubectl
     contrib/mesos
     .generated_docs
   )
@@ -1022,8 +1021,6 @@ function kube::release::package_full_tarball() {
   cp "${KUBE_ROOT}/README.md" "${release_stage}/"
   cp "${KUBE_ROOT}/Godeps/LICENSES" "${release_stage}/"
   cp "${KUBE_ROOT}/Vagrantfile" "${release_stage}/"
-  mkdir -p "${release_stage}/contrib/completions/bash"
-  cp "${KUBE_ROOT}/contrib/completions/bash/kubectl" "${release_stage}/contrib/completions/bash"
 
   echo "${KUBE_GIT_VERSION}" > "${release_stage}/version"
 

cmd/genbashcomp/gen_kubectl_bash_comp.go

-/*
-Copyright 2015 The Kubernetes Authors All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-
-	"k8s.io/kubernetes/cmd/genutils"
-	"k8s.io/kubernetes/pkg/kubectl/cmd"
-	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
-)
-
-func main() {
-	// use os.Args instead of "flags" because "flags" will mess up the man pages!
-	path := "contrib/completions/bash/"
-	if len(os.Args) == 2 {
-		path = os.Args[1]
-	} else if len(os.Args) > 2 {
-		fmt.Fprintf(os.Stderr, "usage: %s [output directory]\n", os.Args[0])
-		os.Exit(1)
-	}
-
-	outDir, err := genutils.OutDir(path)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
-		os.Exit(1)
-	}
-	outFile := outDir + "kubectl"
-
-	// TODO os.Stdin should really be something like ioutil.Discard, but a Reader
-	kubectl := cmd.NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, ioutil.Discard, ioutil.Discard)
-	kubectl.GenBashCompletionFile(outFile)
-}

contrib/completions/bash/MAINTAINERS.md

-# Maintainers
-
-Eric Paris <eparis@redhat.com>
-
-
-[![Analytics](https://kubernetes-site.appspot.com/UA-36037335-10/GitHub/contrib/completions/bash/MAINTAINERS.md?pixel)]()

contrib/completions/zsh/kubectl

-#!/bin/zsh
-
-# Copyright 2016 The Kubernetes Authors All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-__kubectl_bash_source() {
-  alias shopt=':'
-  alias _expand=_bash_expand
-  alias _complete=_bash_comp
-  emulate -L sh
-  setopt kshglob noshglob braceexpand
-
-  source "$@"
-}
-
-__kubectl_type() {
-	# -t is not supported by zsh
-	if [ "$1" == "-t" ]; then
-		shift
-
-		# fake Bash 4 to disable "complete -o nospace". Instead
-		# "compopt +-o nospace" is used in the code to toggle trailing
-		# spaces. We don't support that, but leave trailing spaces on
-		# all the time
-		if [ "$1" = "__kubectl_compopt" ]; then
-			echo builtin
-			return 0
-		fi
-	fi
-	type "$@"
-}
-
-__kubectl_compgen() {
-	local completions w
-	completions=( $(compgen "$@") ) || return $?
-
-	# filter by given word as prefix
-	while [[ "$1" = -* && "$1" != -- ]]; do
-		shift
-		shift
-	done
-	if [[ "$1" == -- ]]; then
-		shift
-	fi
-	for w in "${completions[@]}"; do
-		if [[ "${w}" = "$1"* ]]; then
-			echo "${w}"
-		fi
-	done
-}
-
-__kubectl_compopt() {
-	true # don't do anything. Not supported by bashcompinit in zsh
-}
-
-__kubectl_declare() {
-	if [ "$1" == "-F" ]; then
-		whence -w "$@"
-	else
-		builtin declare "$@"
-	fi
-}
-
-__kubectl_ltrim_colon_completions()
-{
-	if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
-		# Remove colon-word prefix from COMPREPLY items
-		local colon_word=${1%${1##*:}}
-		local i=${#COMPREPLY[*]}
-		while [[ $((--i)) -ge 0 ]]; do
-			COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
-		done
-	fi
-}
-
-__kubectl_get_comp_words_by_ref() {
-	cur="${COMP_WORDS[COMP_CWORD]}"
-	prev="${COMP_WORDS[${COMP_CWORD}-1]}"
-	words=("${COMP_WORDS[@]}")
-	cword=("${COMP_CWORD[@]}")
-}
-
-__kubectl_filedir() {
-	local RET OLD_IFS w qw
-
-	__debug "_filedir $@ cur=$cur"
-	if [[ "$1" = \~* ]]; then
-		# somehow does not work. Maybe, zsh does not call this at all
-		eval echo "$1"
-		return 0
-	fi
-
-	OLD_IFS="$IFS"
-	IFS=$'\n'
-	if [ "$1" = "-d" ]; then
-		shift
-		RET=( $(compgen -d) )
-	else
-		RET=( $(compgen -f) )
-	fi
-	IFS="$OLD_IFS"
-
-	IFS="," __debug "RET=${RET[@]} len=${#RET[@]}"
-
-	for w in ${RET[@]}; do
-		if [[ ! "${w}" = "${cur}"* ]]; then
-			continue
-		fi
-		if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then
-			qw="$(__kubectl_quote "${w}")"
-			if [ -d "${w}" ]; then
-				COMPREPLY+=("${qw}/")
-			else
-				COMPREPLY+=("${qw}")
-			fi
-		fi
-	done
-}
-
-__kubectl_quote() {
-    if [[ $1 == \'* || $1 == \"* ]]; then
-        # Leave out first character
-        printf %q "${1:1}"
-    else
-    	printf %q "$1"
-    fi
-}
-
-autoload -U +X compinit && compinit
-autoload -U +X bashcompinit && bashcompinit
-
-# use word boundary patterns for BSD or GNU sed
-LWORD='[[:<:]]'
-RWORD='[[:>:]]'
-if sed --help 2>&1 | grep -q GNU; then
-	LWORD='\<'
-	RWORD='\>'
-fi
-
-__kubectl_bash_source <(sed \
-	-e 's/declare -F/whence -w/' \
-	-e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \
-	-e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \
-	-e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \
-	-e "s/${LWORD}_filedir${RWORD}/__kubectl_filedir/g" \
-	-e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__kubectl_get_comp_words_by_ref/g" \
-	-e "s/${LWORD}__ltrim_colon_completions${RWORD}/__kubectl_ltrim_colon_completions/g" \
-	-e "s/${LWORD}compgen${RWORD}/__kubectl_compgen/g" \
-	-e "s/${LWORD}compopt${RWORD}/__kubectl_compopt/g" \
-	-e "s/${LWORD}declare${RWORD}/__kubectl_declare/g" \
-	-e "s/\\\$(type${RWORD}/\$(__kubectl_type/g" \
-	$(dirname $0)/../bash/kubectl
-)

hack/lib/golang.sh

@@ -111,7 +111,6 @@ kube::golang::test_targets() {
     cmd/genman
     cmd/genyaml
     cmd/mungedocs
-    cmd/genbashcomp
     cmd/genswaggertypedocs
     cmd/linkcheck
     examples/k8petstore/web-server/src

hack/lib/util.sh

@@ -176,7 +176,7 @@ kube::util::find-binary() {
   echo -n "${bin}"
 }
 
-# Run all known doc generators (today gendocs, genman, and genbashcomp for kubectl)
+# Run all known doc generators (today gendocs and genman for kubectl)
 # $1 is the directory to put those generated documents
 kube::util::gen-docs() {
   local dest="$1"
@@ -186,7 +186,6 @@ kube::util::gen-docs() {
   genkubedocs=$(kube::util::find-binary "genkubedocs")
   genman=$(kube::util::find-binary "genman")
   genyaml=$(kube::util::find-binary "genyaml")
-  genbashcomp=$(kube::util::find-binary "genbashcomp")
   genfeddocs=$(kube::util::find-binary "genfeddocs")
 
   mkdir -p "${dest}/docs/user-guide/kubectl/"
@@ -203,8 +202,6 @@ kube::util::gen-docs() {
   "${genman}" "${dest}/docs/man/man1/"
   mkdir -p "${dest}/docs/yaml/kubectl/"
   "${genyaml}" "${dest}/docs/yaml/kubectl/"
-  mkdir -p "${dest}/contrib/completions/bash/"
-  "${genbashcomp}" "${dest}/contrib/completions/bash/"
 
   # create the list of generated files
   pushd "${dest}" > /dev/null

hack/update-generated-docs.sh

@@ -28,7 +28,6 @@ kube::golang::setup_env
     cmd/genkubedocs \
     cmd/genman \
     cmd/genyaml \
-    cmd/genbashcomp \
     cmd/mungedocs \
     federation/cmd/genfeddocs
 

hack/verify-generated-docs.sh

@@ -28,7 +28,6 @@ kube::golang::setup_env
     cmd/genkubedocs \
     cmd/genman \
     cmd/genyaml \
-    cmd/genbashcomp \
     cmd/mungedocs
 
 # Find binary

pkg/kubectl/cmd/cmd.go

@@ -235,6 +235,7 @@ Find more information at https://github.com/kubernetes/kubernetes.`,
 	cmds.AddCommand(NewCmdVersion(f, out))
 	cmds.AddCommand(NewCmdExplain(f, out))
 	cmds.AddCommand(NewCmdConvert(f, out))
+	cmds.AddCommand(NewCmdCompletion(f, out))
 
 	if cmds.Flag("namespace") != nil {
 		if cmds.Flag("namespace").Annotations == nil {

pkg/kubectl/cmd/completion.go

+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cmd
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/spf13/cobra"
+
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+)
+
+const (
+	completion_long = `Output shell completion code for the given shell (bash or zsh).
+
+This command prints shell code which must be evaluation to provide interactive
+completion of kubectl commands.
+`
+	completion_example = `
+$ source <(kubectl completion bash)
+
+will load the kubectl completion code for bash. Note that this depends on the bash-completion
+framework. It must be sourced before sourcing the kubectl completion, i.e. on the Mac:
+
+$ brew install bash-completion
+$ source $(brew --prefix)/etc/bash_completion
+$ source <(kubectl completion bash)
+
+If you use zsh, the following will load kubectl zsh completion:
+
+$ source <(kubectl completion zsh)
+`
+)
+
+var (
+	completion_shells = map[string]func(out io.Writer, cmd *cobra.Command) error{
+		"bash": runCompletionBash,
+		"zsh":  runCompletionZsh,
+	}
+)
+
+func NewCmdCompletion(f *cmdutil.Factory, out io.Writer) *cobra.Command {
+	shells := []string{}
+	for s := range completion_shells {
+		shells = append(shells, s)
+	}
+
+	cmd := &cobra.Command{
+		Use:     "completion SHELL",
+		Short:   "Output shell completion code for the given shell (bash or zsh)",
+		Long:    completion_long,
+		Example: completion_example,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := RunCompletion(f, out, cmd, args)
+			cmdutil.CheckErr(err)
+		},
+		ValidArgs: shells,
+	}
+
+	return cmd
+}
+
+func RunCompletion(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return cmdutil.UsageError(cmd, "Shell not specified.")
+	}
+	if len(args) > 1 {
+		return cmdutil.UsageError(cmd, "Too many arguments. Expected only the shell type.")
+	}
+	run, found := completion_shells[args[0]]
+	if !found {
+		return cmdutil.UsageError(cmd, "Unsupported shell type %q.", args[0])
+	}
+
+	return run(out, cmd.Parent())
+}
+
+func runCompletionBash(out io.Writer, kubectl *cobra.Command) error {
+	return kubectl.GenBashCompletion(out)
+}
+
+func runCompletionZsh(out io.Writer, kubectl *cobra.Command) error {
+	zsh_initialilzation := `# Copyright 2016 The Kubernetes Authors All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__kubectl_bash_source() {
+	alias shopt=':'
+	alias _expand=_bash_expand
+	alias _complete=_bash_comp
+	emulate -L sh
+	setopt kshglob noshglob braceexpand
+
+	source "$@"
+}
+
+__kubectl_type() {
+	# -t is not supported by zsh
+	if [ "$1" == "-t" ]; then
+		shift
+
+		# fake Bash 4 to disable "complete -o nospace". Instead
+		# "compopt +-o nospace" is used in the code to toggle trailing
+		# spaces. We don't support that, but leave trailing spaces on
+		# all the time
+		if [ "$1" = "__kubectl_compopt" ]; then
+			echo builtin
+			return 0
+		fi
+	fi
+	type "$@"
+}
+
+__kubectl_compgen() {
+	local completions w
+	completions=( $(compgen "$@") ) || return $?
+
+	# filter by given word as prefix
+	while [[ "$1" = -* && "$1" != -- ]]; do
+		shift
+		shift
+	done
+	if [[ "$1" == -- ]]; then
+		shift
+	fi
+	for w in "${completions[@]}"; do
+		if [[ "${w}" = "$1"* ]]; then
+			echo "${w}"
+		fi
+	done
+}
+
+__kubectl_compopt() {
+	true # don't do anything. Not supported by bashcompinit in zsh
+}
+
+__kubectl_declare() {
+	if [ "$1" == "-F" ]; then
+		whence -w "$@"
+	else
+		builtin declare "$@"
+	fi
+}
+
+__kubectl_ltrim_colon_completions()
+{
+	if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
+		# Remove colon-word prefix from COMPREPLY items
+		local colon_word=${1%${1##*:}}
+		local i=${#COMPREPLY[*]}
+		while [[ $((--i)) -ge 0 ]]; do
+			COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
+		done
+	fi
+}
+
+__kubectl_get_comp_words_by_ref() {
+	cur="${COMP_WORDS[COMP_CWORD]}"
+	prev="${COMP_WORDS[${COMP_CWORD}-1]}"
+	words=("${COMP_WORDS[@]}")
+	cword=("${COMP_CWORD[@]}")
+}
+
+__kubectl_filedir() {
+	local RET OLD_IFS w qw
+
+	__debug "_filedir $@ cur=$cur"
+	if [[ "$1" = \~* ]]; then
+		# somehow does not work. Maybe, zsh does not call this at all
+		eval echo "$1"
+		return 0
+	fi
+
+	OLD_IFS="$IFS"
+	IFS=$'\n'
+	if [ "$1" = "-d" ]; then
+		shift
+		RET=( $(compgen -d) )
+	else
+		RET=( $(compgen -f) )
+	fi
+	IFS="$OLD_IFS"
+
+	IFS="," __debug "RET=${RET[@]} len=${#RET[@]}"
+
+	for w in ${RET[@]}; do
+		if [[ ! "${w}" = "${cur}"* ]]; then
+			continue
+		fi
+		if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then
+			qw="$(__kubectl_quote "${w}")"
+			if [ -d "${w}" ]; then
+				COMPREPLY+=("${qw}/")
+			else
+				COMPREPLY+=("${qw}")
+			fi
+		fi
+	done
+}
+
+__kubectl_quote() {
+    if [[ $1 == \'* || $1 == \"* ]]; then
+        # Leave out first character
+        printf %q "${1:1}"
+    else
+    	printf %q "$1"
+    fi
+}
+
+autoload -U +X compinit && compinit
+autoload -U +X bashcompinit && bashcompinit
+
+# use word boundary patterns for BSD or GNU sed
+LWORD='[[:<:]]'
+RWORD='[[:>:]]'
+if sed --help 2>&1 | grep -q GNU; then
+	LWORD='\<'
+	RWORD='\>'
+fi
+
+__kubectl_bash_source <(sed \
+	-e 's/declare -F/whence -w/' \
+	-e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \
+	-e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \
+	-e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \
+	-e "s/${LWORD}_filedir${RWORD}/__kubectl_filedir/g" \
+	-e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__kubectl_get_comp_words_by_ref/g" \
+	-e "s/${LWORD}__ltrim_colon_completions${RWORD}/__kubectl_ltrim_colon_completions/g" \
+	-e "s/${LWORD}compgen${RWORD}/__kubectl_compgen/g" \
+	-e "s/${LWORD}compopt${RWORD}/__kubectl_compopt/g" \
+	-e "s/${LWORD}declare${RWORD}/__kubectl_declare/g" \
+	-e "s/\\\$(type${RWORD}/\$(__kubectl_type/g" \
+	<<'BASH_COMPLETION_EOF'
+`
+	out.Write([]byte(zsh_initialilzation))
+
+	buf := new(bytes.Buffer)
+	kubectl.GenBashCompletion(buf)
+	out.Write(buf.Bytes())
+
+	zsh_tail := `
+BASH_COMPLETION_EOF
+)
+`
+	out.Write([]byte(zsh_tail))
+	return nil
+}