@@ -78,10 +78,11 @@ func NewCommandCLI(name, fullName string, in io.Reader, out, errout io.Writer) *

 		Short: "Command line tools for managing applications",

 		Long:  cliLong,

 		Run: func(c *cobra.Command, args []string) {

-			c.SetOutput(out)

+			explainOut := term.NewResponsiveWriter(out)

+			c.SetOutput(explainOut)

 			cmdutil.RequireNoArguments(c, args)

-			fmt.Fprint(out, cliLong)

-			fmt.Fprintf(out, cliExplain, fullName)

+			fmt.Fprint(explainOut, cliLong)

+			fmt.Fprintf(explainOut, cliExplain, fullName)

 		},

 		BashCompletionFunction: bashCompletionFunc,

 	}

@@ -10,17 +10,17 @@ import (

 	"net/url"

 	"os"

-	cmdutil "github.com/openshift/origin/pkg/cmd/util"

+	"github.com/openshift/origin/pkg/client"

+	"github.com/openshift/origin/pkg/user/api"

+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"

+

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	kapi "k8s.io/kubernetes/pkg/api"

 	kerrors "k8s.io/kubernetes/pkg/api/errors"

 	"k8s.io/kubernetes/pkg/client/restclient"

-	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"

 	kclientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"

 	"k8s.io/kubernetes/pkg/util/sets"

-	"k8s.io/kubernetes/pkg/util/term"

-

-	"github.com/openshift/origin/pkg/client"

-	"github.com/openshift/origin/pkg/user/api"

+	kterm "k8s.io/kubernetes/pkg/util/term"

 )

 // getMatchingClusters examines the kubeconfig for all clusters that point to the same server

@@ -96,12 +96,12 @@ func promptForInsecureTLS(reader io.Reader, out io.Writer, reason error) bool {

 		}

 	}

 	var input bool

-	if term.IsTerminal(reader) {

+	if kterm.IsTerminal(reader) {

 		if len(insecureTLSRequestReason) > 0 {

 			fmt.Fprintln(out, insecureTLSRequestReason)

 		}

 		fmt.Fprintln(out, "You can bypass the certificate check, but any data you send to the server could be intercepted by others.")

-		input = cmdutil.PromptForBool(os.Stdin, out, "Use insecure connections? (y/n): ")

+		input = term.PromptForBool(os.Stdin, out, "Use insecure connections? (y/n): ")

 		fmt.Fprintln(out)

 	}

 	return input

@@ -17,7 +17,7 @@ import (

 	kclientcmd "k8s.io/kubernetes/pkg/client/unversioned/clientcmd"

 	kclientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"

 	"k8s.io/kubernetes/pkg/util/sets"

-	"k8s.io/kubernetes/pkg/util/term"

+	kterm "k8s.io/kubernetes/pkg/util/term"

 	"github.com/openshift/origin/pkg/client"

 	"github.com/openshift/origin/pkg/cmd/cli/cmd/errors"

@@ -25,6 +25,7 @@ import (

 	cmderr "github.com/openshift/origin/pkg/cmd/errors"

 	cmdutil "github.com/openshift/origin/pkg/cmd/util"

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/openshift/origin/pkg/cmd/util/tokencmd"

 	"github.com/openshift/origin/pkg/user/api"

 )

@@ -86,11 +87,11 @@ func (o *LoginOptions) getClientConfig() (*restclient.Config, error) {

 	if len(o.Server) == 0 {

 		// we need to have a server to talk to

-		if term.IsTerminal(o.Reader) {

+		if kterm.IsTerminal(o.Reader) {

 			for !o.serverProvided() {

 				defaultServer := defaultClusterURL

 				promptMsg := fmt.Sprintf("Server [%s]: ", defaultServer)

-				o.Server = cmdutil.PromptForStringWithDefault(o.Reader, o.Out, defaultServer, promptMsg)

+				o.Server = term.PromptForStringWithDefault(o.Reader, o.Out, defaultServer, promptMsg)

 			}

 		}

 	}

@@ -12,6 +12,7 @@ import (

 	"github.com/openshift/origin/pkg/client"

 	cliconfig "github.com/openshift/origin/pkg/cmd/cli/config"

+	"github.com/openshift/origin/pkg/cmd/templates"

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

 	projectapi "github.com/openshift/origin/pkg/project/api"

 )

@@ -37,20 +38,21 @@ type NewProjectOptions struct {

 }

 // RequestProject command description.

-const (

-	requestProjectLong = `

-Create a new project for yourself

+var (

+	requestProjectLong = templates.LongDesc(`

+		Create a new project for yourself

-If your administrator allows self-service, this command will create a new project for you and assign you

-as the project admin.

+		If your administrator allows self-service, this command will create a new project for you and assign you

+		as the project admin.

-After your project is created it will become the default project in your config.`

+		After your project is created it will become the default project in your config.`)

-	requestProjectExample = `  # Create a new project with minimal information

-  %[1]s %[2]s web-team-dev

+	requestProjectExample = templates.Examples(`

+		# Create a new project with minimal information

+	  %[1]s %[2]s web-team-dev

-  # Create a new project with a display name and description

-  %[1]s %[2]s web-team-dev --display-name="Web Team Development" --description="Development project for the web team."`

+	  # Create a new project with a display name and description

+	  %[1]s %[2]s web-team-dev --display-name="Web Team Development" --description="Development project for the web team."`)

 )

 // RequestProject next steps.

@@ -71,7 +73,7 @@ To switch to this project and start adding applications, use:

 )

 // NewCmdRequestProject implement the OpenShift cli RequestProject command.

-func NewCmdRequestProject(name, baseName string, f *clientcmd.Factory, out io.Writer) *cobra.Command {

+func NewCmdRequestProject(name, baseName string, f *clientcmd.Factory, out, errout io.Writer) *cobra.Command {

 	o := &NewProjectOptions{}

 	o.Out = out

 	o.Name = baseName

@@ -12,8 +12,8 @@ import (

 	"k8s.io/kubernetes/pkg/client/unversioned"

 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

-	"github.com/openshift/origin/pkg/cmd/util"

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/openshift/origin/pkg/serviceaccounts"

 )

@@ -128,7 +128,7 @@ func (o *GetServiceAccountTokenOptions) Run() error {

 			}

 			fmt.Fprintf(o.Out, string(token))

-			if util.IsTerminalWriter(o.Out) {

+			if term.IsTerminalWriter(o.Out) {

 				// pretty-print for a TTY

 				fmt.Fprintf(o.Out, "\n")

 			}

@@ -17,8 +17,8 @@ import (

 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

 	"k8s.io/kubernetes/pkg/watch"

-	"github.com/openshift/origin/pkg/cmd/util"

 	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/openshift/origin/pkg/serviceaccounts"

 	osautil "github.com/openshift/origin/pkg/serviceaccounts/util"

 )

@@ -176,7 +176,7 @@ func (o *NewServiceAccountTokenOptions) Run() error {

 	}

 	fmt.Fprintf(o.Out, string(token))

-	if util.IsTerminalWriter(o.Out) {

+	if term.IsTerminalWriter(o.Out) {

 		// pretty-print for a TTY

 		fmt.Fprintf(o.Out, "\n")

 	}

@@ -11,9 +11,9 @@ import (

 	"k8s.io/kubernetes/pkg/api"

 	client "k8s.io/kubernetes/pkg/client/unversioned"

 	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

-	"k8s.io/kubernetes/pkg/util/term"

+	kterm "k8s.io/kubernetes/pkg/util/term"

-	cmdutil "github.com/openshift/origin/pkg/cmd/util"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 )

 const (

@@ -166,11 +166,11 @@ func (o *CreateBasicAuthSecretOptions) Complete(f *kcmdutil.Factory, args []stri

 		if len(o.Password) != 0 {

 			return errors.New("must provide either --prompt or --password flag")

 		}

-		if !term.IsTerminal(o.Reader) {

+		if !kterm.IsTerminal(o.Reader) {

 			return errors.New("provided reader is not a terminal")

 		}

-		o.Password = cmdutil.PromptForPasswordString(o.Reader, o.Out, "Password: ")

+		o.Password = term.PromptForPasswordString(o.Reader, o.Out, "Password: ")

 		if len(o.Password) == 0 {

 			return errors.New("password must be provided")

 		}

@@ -8,7 +8,7 @@ import (

 	"io/ioutil"

 	"os"

-	"github.com/openshift/origin/pkg/cmd/util"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/spf13/cobra"

 	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

@@ -38,7 +38,7 @@ type DecryptOptions struct {

 const decryptExample = `	# Decrypt an encrypted file to a cleartext file:

 	%[1]s --key=secret.key --in=secret.encrypted --out=secret.decrypted

-	

+

 	# Decrypt from stdin to stdout:

 	%[1]s --key=secret.key < secret2.encrypted > secret2.decrypted

 `

@@ -79,7 +79,7 @@ func (o *DecryptOptions) Validate(args []string) error {

 		return errors.New("no arguments are supported")

 	}

-	if len(o.EncryptedFile) == 0 && len(o.EncryptedData) == 0 && (o.EncryptedReader == nil || util.IsTerminalReader(o.EncryptedReader)) {

+	if len(o.EncryptedFile) == 0 && len(o.EncryptedData) == 0 && (o.EncryptedReader == nil || term.IsTerminalReader(o.EncryptedReader)) {

 		return errors.New("no input data specified")

 	}

 	if len(o.EncryptedFile) > 0 && len(o.EncryptedData) > 0 {

@@ -105,7 +105,7 @@ func (o *DecryptOptions) Decrypt() error {

 		}

 	case len(o.EncryptedData) > 0:

 		data = o.EncryptedData

-	case o.EncryptedReader != nil && !util.IsTerminalReader(o.EncryptedReader):

+	case o.EncryptedReader != nil && !term.IsTerminalReader(o.EncryptedReader):

 		if d, err := ioutil.ReadAll(o.EncryptedReader); err != nil {

 			return err

 		} else {

@@ -147,7 +147,7 @@ func (o *DecryptOptions) Decrypt() error {

 		}

 	case o.DecryptedWriter != nil:

 		fmt.Fprint(o.DecryptedWriter, string(plaintext))

-		if util.IsTerminalWriter(o.DecryptedWriter) {

+		if term.IsTerminalWriter(o.DecryptedWriter) {

 			fmt.Fprintln(o.DecryptedWriter)

 		}

 	}

@@ -12,12 +12,12 @@ import (

 	"unicode"

 	"unicode/utf8"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/spf13/cobra"

 	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

 	configapi "github.com/openshift/origin/pkg/cmd/server/api"

-	"github.com/openshift/origin/pkg/cmd/util"

 	pemutil "github.com/openshift/origin/pkg/cmd/util/pem"

 )

@@ -47,7 +47,7 @@ type EncryptOptions struct {

 const encryptExample = `	# Encrypt the content of secret.txt with a generated key:

 	%[1]s --genkey=secret.key --in=secret.txt --out=secret.encrypted

-	

+

 	# Encrypt the content of secret2.txt with an existing key:

 	%[1]s --key=secret.key < secret2.txt > secret2.encrypted

 `

@@ -127,9 +127,9 @@ func (o *EncryptOptions) Encrypt() error {

 		// Don't warn in cases where we're explicitly being given the data to use

 		warnWhitespace = false

 		data = o.CleartextData

-	case o.CleartextReader != nil && util.IsTerminalReader(o.CleartextReader) && o.PromptWriter != nil:

+	case o.CleartextReader != nil && term.IsTerminalReader(o.CleartextReader) && o.PromptWriter != nil:

 		// Read a single line from stdin with prompting

-		data = []byte(util.PromptForString(o.CleartextReader, o.PromptWriter, "Data to encrypt: "))

+		data = []byte(term.PromptForString(o.CleartextReader, o.PromptWriter, "Data to encrypt: "))

 	case o.CleartextReader != nil:

 		// Read data from stdin without prompting (allows binary data and piping)

 		if d, err := ioutil.ReadAll(o.CleartextReader); err != nil {

@@ -7,6 +7,7 @@ import (

 	"text/template"

 	"unicode"

+	"github.com/openshift/origin/pkg/cmd/util/term"

 	"github.com/spf13/cobra"

 	flag "github.com/spf13/pflag"

 )

@@ -81,27 +82,30 @@ func ActsAsRootCommand(cmd *cobra.Command, filters []string, groups ...CommandGr

 	if cmd == nil {

 		panic("nil root command")

 	}

-	cmd.SetHelpTemplate(MainHelpTemplate())

 	templater := &templater{

 		RootCmd:       cmd,

 		UsageTemplate: MainUsageTemplate(),

+		HelpTemplate:  MainHelpTemplate(),

 		CommandGroups: groups,

 		Filtered:      filters,

 	}

 	cmd.SetUsageFunc(templater.UsageFunc())

+	cmd.SetHelpFunc(templater.HelpFunc())

 	return templater

 }

 func UseOptionsTemplates(cmd *cobra.Command) {

-	cmd.SetHelpTemplate(OptionsHelpTemplate())

 	templater := &templater{

 		UsageTemplate: OptionsUsageTemplate(),

+		HelpTemplate:  OptionsHelpTemplate(),

 	}

 	cmd.SetUsageFunc(templater.UsageFunc())

+	cmd.SetHelpFunc(templater.HelpFunc())

 }

 type templater struct {

 	UsageTemplate string

+	HelpTemplate  string

 	RootCmd       *cobra.Command

 	CommandGroups

 	Filtered []string

@@ -112,39 +116,55 @@ func (templater *templater) ExposeFlags(cmd *cobra.Command, flags ...string) Fla

 	return templater

 }

+func (templater *templater) HelpFunc() func(*cobra.Command, []string) {

+	return func(c *cobra.Command, s []string) {

+		t := template.New("help")

+		t.Funcs(templater.templateFuncs())

+		template.Must(t.Parse(templater.HelpTemplate))

+		out := term.NewResponsiveWriter(c.OutOrStdout())

+		err := t.Execute(out, c)

+		if err != nil {

+			c.Println(err)

+		}

+	}

+}

+

 func (templater *templater) UsageFunc(exposedFlags ...string) func(*cobra.Command) error {

 	return func(c *cobra.Command) error {

-		t := template.New("custom")

-

-		t.Funcs(template.FuncMap{

-			"trim":                strings.TrimSpace,

-			"trimRight":           func(s string) string { return strings.TrimRightFunc(s, unicode.IsSpace) },

-			"gt":                  cobra.Gt,

-			"eq":                  cobra.Eq,

-			"rpad":                rpad,

-			"flagsNotIntersected": flagsNotIntersected,

-			"visibleFlags":        visibleFlags,

-			"flagsUsages":         flagsUsages,

-			"cmdGroups":           templater.cmdGroups,

-			"rootCmd":             templater.rootCmdName,

-			"isRootCmd":           templater.isRootCmd,

-			"optionsCmdFor":       templater.optionsCmdFor,

-			"usageLine":           templater.usageLine,

-			"exposed": func(c *cobra.Command) *flag.FlagSet {

-				exposed := flag.NewFlagSet("exposed", flag.ContinueOnError)

-				if len(exposedFlags) > 0 {

-					for _, name := range exposedFlags {

-						if flag := c.Flags().Lookup(name); flag != nil {

-							exposed.AddFlag(flag)

-						}

+		t := template.New("usage")

+		t.Funcs(templater.templateFuncs(exposedFlags...))

+		template.Must(t.Parse(templater.UsageTemplate))

+		out := term.NewResponsiveWriter(c.OutOrStderr())

+		return t.Execute(out, c)

+	}

+}

+

+func (templater *templater) templateFuncs(exposedFlags ...string) template.FuncMap {

+	return template.FuncMap{

+		"trim":                strings.TrimSpace,

+		"trimRight":           func(s string) string { return strings.TrimRightFunc(s, unicode.IsSpace) },

+		"gt":                  cobra.Gt,

+		"eq":                  cobra.Eq,

+		"rpad":                rpad,

+		"flagsNotIntersected": flagsNotIntersected,

+		"visibleFlags":        visibleFlags,

+		"flagsUsages":         flagsUsages,

+		"cmdGroups":           templater.cmdGroups,

+		"rootCmd":             templater.rootCmdName,

+		"isRootCmd":           templater.isRootCmd,

+		"optionsCmdFor":       templater.optionsCmdFor,

+		"usageLine":           templater.usageLine,

+		"exposed": func(c *cobra.Command) *flag.FlagSet {

+			exposed := flag.NewFlagSet("exposed", flag.ContinueOnError)

+			if len(exposedFlags) > 0 {

+				for _, name := range exposedFlags {

+					if flag := c.Flags().Lookup(name); flag != nil {

+						exposed.AddFlag(flag)

 					}

 				}

-				return exposed

-			},

-		})

-

-		template.Must(t.Parse(templater.UsageTemplate))

-		return t.Execute(c.OutOrStderr(), c)

+			}

+			return exposed

+		},

 	}

 }

new file mode 100644

@@ -0,0 +1,122 @@

+package term

+

+import (

+	"bufio"

+	"fmt"

+	"io"

+	"os"

+	"strings"

+

+	"github.com/docker/docker/pkg/term"

+	"github.com/golang/glog"

+

+	kterm "k8s.io/kubernetes/pkg/util/term"

+)

+

+// PromptForString takes an io.Reader and prompts for user input if it's a terminal, returning the result.

+func PromptForString(r io.Reader, w io.Writer, format string, a ...interface{}) string {

+	if w == nil {

+		w = os.Stdout

+	}

+

+	fmt.Fprintf(w, format, a...)

+	return readInput(r)

+}

+

+// PromptForPasswordString prompts for user input by disabling echo in terminal, useful for password prompt.

+func PromptForPasswordString(r io.Reader, w io.Writer, format string, a ...interface{}) string {

+	if w == nil {

+		w = os.Stdout

+	}

+

+	if file, ok := r.(*os.File); ok {

+		inFd := file.Fd()

+

+		if term.IsTerminal(inFd) {

+			oldState, err := term.SaveState(inFd)

+			if err != nil {

+				glog.V(3).Infof("Unable to save terminal state")

+				return PromptForString(r, w, format, a...)

+			}

+

+			fmt.Fprintf(w, format, a...)

+

+			term.DisableEcho(inFd, oldState)

+

+			input := readInput(r)

+

+			defer term.RestoreTerminal(inFd, oldState)

+

+			fmt.Fprintf(w, "\n")

+

+			return input

+		}

+		glog.V(3).Infof("Stdin is not a terminal")

+		return PromptForString(r, w, format, a...)

+	}

+	return PromptForString(r, w, format, a...)

+}

+

+// PromptForBool prompts for user input of a boolean value. The accepted values are:

+//   yes, y, true, 	t, 1 (not case sensitive)

+//   no, 	n, false, f, 0 (not case sensitive)

+// A valid answer is mandatory so it will keep asking until an answer is provided.

+func PromptForBool(r io.Reader, w io.Writer, format string, a ...interface{}) bool {

+	if w == nil {

+		w = os.Stdout

+	}

+

+	str := PromptForString(r, w, format, a...)

+	switch strings.ToLower(str) {

+	case "1", "t", "true", "y", "yes":

+		return true

+	case "0", "f", "false", "n", "no":

+		return false

+	}

+	fmt.Println("Please enter 'yes' or 'no'.")

+	return PromptForBool(r, w, format, a...)

+}

+

+// PromptForStringWithDefault prompts for user input but take a default in case nothing is provided.

+func PromptForStringWithDefault(r io.Reader, w io.Writer, def string, format string, a ...interface{}) string {

+	if w == nil {

+		w = os.Stdout

+	}

+

+	s := PromptForString(r, w, format, a...)

+	if len(s) == 0 {

+		return def

+	}

+	return s

+}

+

+func readInput(r io.Reader) string {

+	if kterm.IsTerminal(r) {

+		return readInputFromTerminal(r)

+	}

+	return readInputFromReader(r)

+}

+

+func readInputFromTerminal(r io.Reader) string {

+	reader := bufio.NewReader(r)

+	result, _ := reader.ReadString('\n')

+	return strings.TrimRight(result, "\r\n")

+}

+

+func readInputFromReader(r io.Reader) string {

+	var result string

+	fmt.Fscan(r, &result)

+	return result

+}

+

+// IsTerminalReader returns whether the passed io.Reader is a terminal or not

+func IsTerminalReader(r io.Reader) bool {

+	file, ok := r.(*os.File)

+	return ok && term.IsTerminal(file.Fd())

+}

+

+// IsTerminalWriter returns whether the passed io.Writer is a terminal or not

+func IsTerminalWriter(w io.Writer) bool {

+	file, ok := w.(*os.File)

+	return ok && term.IsTerminal(file.Fd())

+}

new file mode 100644

@@ -0,0 +1,33 @@

+package term

+

+import (

+	"strings"

+	"testing"

+)

+

+func TestReadInputFromTerminal(t *testing.T) {

+	testcases := map[string]struct {

+		Input  string

+		Output string

+	}{

+		"empty":                             {},

+		"empty newline":                     {Input: "\n"},

+		"empty windows newline":             {Input: "\r\n"},

+		"empty newline with extra":          {Input: "\nextra"},

+		"leading space":                     {Input: " data", Output: " data"},

+		"leading space newline":             {Input: " data\n", Output: " data"},

+		"leading space windows newline":     {Input: " data\r\n", Output: " data"},

+		"leading space newline with extra":  {Input: " data\nextra", Output: " data"},

+		"trailing space":                    {Input: " data ", Output: " data "},

+		"trailing space newline":            {Input: " data \n", Output: " data "},

+		"trailing space windows newline":    {Input: " data \r\n", Output: " data "},

+		"trailing space newline with extra": {Input: " data \nextra", Output: " data "},

+	}

+

+	for k, tc := range testcases {

+		output := readInputFromTerminal(strings.NewReader(tc.Input))

+		if output != tc.Output {

+			t.Errorf("%s: Expected '%s', got '%s'", k, tc.Output, output)

+		}

+	}

+}

new file mode 100644

@@ -0,0 +1,109 @@

+package term

+

+import (

+	"io"

+	"os"

+

+	"github.com/docker/docker/pkg/term"

+	wordwrap "github.com/mitchellh/go-wordwrap"

+	kterm "k8s.io/kubernetes/pkg/util/term"

+)

+

+type wordWrapWriter struct {

+	limit  uint

+	writer io.Writer

+}

+

+// NewResponsiveWriter creates a Writer that detects the column width of the

+// terminal we are in, and adjusts every line width to fit and use recommended

+// terminal sizes for better readability. Does proper word wrapping automatically.

+//    if terminal width >= 120 columns		use 120 columns

+//    if terminal width >= 100 columns		use 100 columns

+//    if terminal width >=  80 columns		use  80 columns

+// In case we're not in a terminal or if it's smaller than 80 columns width,

+// doesn't do any wrapping.

+func NewResponsiveWriter(w io.Writer) io.Writer {

+	file, ok := w.(*os.File)

+	if !ok {

+		return w

+	}

+	fd := file.Fd()

+	if !term.IsTerminal(fd) {

+		return w

+	}

+

+	terminalSize := kterm.GetSize(fd)

+	if terminalSize == nil {

+		return w

+	}

+

+	var limit uint

+	switch {

+	case terminalSize.Width >= 120:

+		limit = 120

+	case terminalSize.Width >= 100:

+		limit = 100

+	case terminalSize.Width >= 80:

+		limit = 80

+	}

+

+	return NewWordWrapWriter(w, limit)

+}

+

+// NewWordWrapWriter is a Writer that supports a limit of characters on every line

+// and does auto word wrapping that respects that limit.

+func NewWordWrapWriter(w io.Writer, limit uint) io.Writer {

+	return &wordWrapWriter{

+		limit:  limit,

+		writer: w,

+	}

+}

+

+func (w wordWrapWriter) Write(p []byte) (nn int, err error) {

+	if w.limit == 0 {

+		return w.writer.Write(p)

+	}

+	original := string(p)

+	wrapped := wordwrap.WrapString(original, w.limit)

+	return w.writer.Write([]byte(wrapped))

+}

+

+// NewPunchCardWriter is a NewWordWrapWriter that limits the line width to 80 columns.

+func NewPunchCardWriter(w io.Writer) io.Writer {

+	return NewWordWrapWriter(w, 80)

+}

+

+type maxWidthWriter struct {

+	maxWidth     uint

+	currentWidth uint

+	written      uint

+	writer       io.Writer

+}

+

+// NewMaxWidthWriter is a Writer that supports a limit of characters on every

+// line, but doesn't do any word wrapping automatically.

+func NewMaxWidthWriter(w io.Writer, maxWidth uint) io.Writer {

+	return &maxWidthWriter{

+		maxWidth: maxWidth,

+		writer:   w,

+	}

+}

+

+func (m maxWidthWriter) Write(p []byte) (nn int, err error) {

+	for _, b := range p {

+		if m.currentWidth == m.maxWidth {

+			m.writer.Write([]byte{'\n'})

+			m.currentWidth = 0

+		}

+		if b == '\n' {

+			m.currentWidth = 0

+		}

+		_, err := m.writer.Write([]byte{b})

+		if err != nil {

+			return int(m.written), err

+		}

+		m.written++

+		m.currentWidth++

+	}

+	return len(p), nil

+}

new file mode 100644

@@ -0,0 +1,82 @@

+package term

+

+import (

+	"bytes"

+	"strings"

+	"testing"

+)

+

+const test = "Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin Origin"

+

+func TestWordWrapWriter(t *testing.T) {

+	testcases := map[string]struct {

+		input    string

+		maxWidth uint

+	}{

+		"max 10":   {input: test, maxWidth: 10},

+		"max 80":   {input: test, maxWidth: 80},

+		"max 120":  {input: test, maxWidth: 120},

+		"max 5000": {input: test, maxWidth: 5000},

+	}

+	for k, tc := range testcases {

+		b := bytes.NewBufferString("")

+		w := NewWordWrapWriter(b, tc.maxWidth)

+		_, err := w.Write([]byte(tc.input))

+		if err != nil {

+			t.Errorf("%s: Unexpected error: %v", k, err)

+		}

+		result := b.String()

+		if !strings.Contains(result, "Origin") {

+			t.Errorf("%s: Expected to contain \"Origin\"", k)

+		}

+		if len(result) < len(tc.input) {

+			t.Errorf("%s: Unexpectedly short string, got %d wanted at least %d chars: %q", k, len(result), len(tc.input), result)

+		}

+		for _, line := range strings.Split(result, "\n") {

+			if len(line) > int(tc.maxWidth) {

+				t.Errorf("%s: Every line must be at most %d chars long, got %d: %q", k, tc.maxWidth, len(line), line)

+			}

+		}

+		for _, word := range strings.Split(result, " ") {

+			if !strings.Contains(word, "Origin") {

+				t.Errorf("%s: Unexpected broken word: %q", k, word)

+			}

+		}

+	}

+}

+

+func TestMaxWidthWriter(t *testing.T) {

+	testcases := map[string]struct {

+		input    string

+		maxWidth uint

+	}{

+		"max 10":   {input: test, maxWidth: 10},

+		"max 80":   {input: test, maxWidth: 80},

+		"max 120":  {input: test, maxWidth: 120},

+		"max 5000": {input: test, maxWidth: 5000},

+	}

+	for k, tc := range testcases {

+		b := bytes.NewBufferString("")

+		w := NewMaxWidthWriter(b, tc.maxWidth)

+		_, err := w.Write([]byte(tc.input))

+		if err != nil {

+			t.Errorf("%s: Unexpected error: %v", k, err)

+		}

+		result := b.String()

+		if !strings.Contains(result, "Origin") {

+			t.Errorf("%s: Expected to contain \"Origin\"", k)

+		}

+		if len(result) < len(tc.input) {

+			t.Errorf("%s: Unexpectedly short string, got %d wanted at least %d chars: %q", k, len(result), len(tc.input), result)

+		}

+		lines := strings.Split(result, "\n")

+		for i, line := range lines {

+			if len(line) > int(tc.maxWidth) {

+				t.Errorf("%s: Every line must be at most %d chars long, got %d: %q", k, tc.maxWidth, len(line), line)

+			}

+			if i < len(lines)-1 && len(line) != int(tc.maxWidth) {

+				t.Errorf("%s: Lines except the last one are expected to be exactly %d chars long, got %d: %q", k, tc.maxWidth, len(line), line)

+			}

+		}

+	}

+}

deleted file mode 100644

@@ -1,122 +0,0 @@

-package util

-

-import (

-	"bufio"

-	"fmt"

-	"io"

-	"os"

-	"strings"

-

-	"github.com/docker/docker/pkg/term"

-	"github.com/golang/glog"

-

-	kterm "k8s.io/kubernetes/pkg/util/term"

-)

-

-// PromptForString takes an io.Reader and prompts for user input if it's a terminal, returning the result.

-func PromptForString(r io.Reader, w io.Writer, format string, a ...interface{}) string {

-	if w == nil {

-		w = os.Stdout

-	}

-

-	fmt.Fprintf(w, format, a...)

-	return readInput(r)

-}

-

-// PromptForPasswordString prompts for user input by disabling echo in terminal, useful for password prompt.

-func PromptForPasswordString(r io.Reader, w io.Writer, format string, a ...interface{}) string {

-	if w == nil {

-		w = os.Stdout

-	}

-

-	if file, ok := r.(*os.File); ok {

-		inFd := file.Fd()

-

-		if term.IsTerminal(inFd) {

-			oldState, err := term.SaveState(inFd)

-			if err != nil {

-				glog.V(3).Infof("Unable to save terminal state")

-				return PromptForString(r, w, format, a...)

-			}

-

-			fmt.Fprintf(w, format, a...)

-

-			term.DisableEcho(inFd, oldState)

-

-			input := readInput(r)

-

-			defer term.RestoreTerminal(inFd, oldState)

-

-			fmt.Fprintf(w, "\n")

-

-			return input

-		}

-		glog.V(3).Infof("Stdin is not a terminal")

-		return PromptForString(r, w, format, a...)

-	}

-	return PromptForString(r, w, format, a...)

-}

-

-// PromptForBool prompts for user input of a boolean value. The accepted values are:

-//   yes, y, true, 	t, 1 (not case sensitive)

-//   no, 	n, false, f, 0 (not case sensitive)

-// A valid answer is mandatory so it will keep asking until an answer is provided.

-func PromptForBool(r io.Reader, w io.Writer, format string, a ...interface{}) bool {

-	if w == nil {

-		w = os.Stdout

-	}

-

-	str := PromptForString(r, w, format, a...)

-	switch strings.ToLower(str) {

-	case "1", "t", "true", "y", "yes":

-		return true

-	case "0", "f", "false", "n", "no":

-		return false

-	}

-	fmt.Println("Please enter 'yes' or 'no'.")

-	return PromptForBool(r, w, format, a...)

-}

-

-// PromptForStringWithDefault prompts for user input but take a default in case nothing is provided.

-func PromptForStringWithDefault(r io.Reader, w io.Writer, def string, format string, a ...interface{}) string {

-	if w == nil {

-		w = os.Stdout

-	}

-

-	s := PromptForString(r, w, format, a...)

-	if len(s) == 0 {

-		return def

-	}

-	return s

-}

-

-func readInput(r io.Reader) string {

-	if kterm.IsTerminal(r) {

-		return readInputFromTerminal(r)

-	}

-	return readInputFromReader(r)

-}

-

-func readInputFromTerminal(r io.Reader) string {

-	reader := bufio.NewReader(r)

-	result, _ := reader.ReadString('\n')

-	return strings.TrimRight(result, "\r\n")

-}

-

-func readInputFromReader(r io.Reader) string {

-	var result string

-	fmt.Fscan(r, &result)