Example #1
0
func main() {
	// Well? [yN]:
	boolAnsFalseDefault := false
	err := interact.NewInteraction("Well?").Resolve(&boolAnsFalseDefault)
	if err != nil {
		fatal(err)
	}

	fmt.Println(boolAnsFalseDefault)

	// Well? [Yn]:
	boolAnsTrueDefault := true
	err = interact.NewInteraction("Well?").Resolve(&boolAnsTrueDefault)
	if err != nil {
		fatal(err)
	}

	fmt.Println(boolAnsTrueDefault)

	// Well? [yn]:
	var boolAnsNoDefault bool
	err = interact.NewInteraction("Well?").Resolve(interact.Required(&boolAnsNoDefault))
	if err != nil {
		fatal(err)
	}

	fmt.Println(boolAnsNoDefault)

	// Message (hello):
	strAnsDefault := "hello"
	err = interact.NewInteraction("Message").Resolve(&strAnsDefault)
	if err != nil {
		fatal(err)
	}

	fmt.Println(strAnsDefault)

	// Message ():
	var strAnsEmptyDefault string
	err = interact.NewInteraction("Message").Resolve(&strAnsEmptyDefault)
	if err != nil {
		fatal(err)
	}

	fmt.Println(strAnsEmptyDefault)

	// Message:
	var strAnsNoDefault string
	err = interact.NewInteraction("Message").Resolve(interact.Required(&strAnsNoDefault))
	if err != nil {
		fatal(err)
	}

	fmt.Println(strAnsNoDefault)

	numbers := []string{"uno", "dos", "tres"}

	// 1: One
	// 2: Two
	// 3: Three
	// Choose a number:
	var chosenFoo string
	err = interact.NewInteraction(
		"Choose a number",
		interact.Choice{Display: "One", Value: numbers[0]},
		interact.Choice{Display: "Two", Value: numbers[1]},
		interact.Choice{Display: "Three", Value: numbers[2]},
	).Resolve(&chosenFoo)
	if err != nil {
		fatal(err)
	}

	fmt.Println(chosenFoo)

	// 1: One
	// 2: Two
	// 3: Three
	// Choose a number (2):
	chosenFooWithDefault := "dos"
	err = interact.NewInteraction(
		"Choose a number",
		interact.Choice{Display: "One", Value: numbers[0]},
		interact.Choice{Display: "Two", Value: numbers[1]},
		interact.Choice{Display: "Three", Value: numbers[2]},
	).Resolve(&chosenFooWithDefault)
	if err != nil {
		fatal(err)
	}

	fmt.Println(chosenFooWithDefault)

	// 1. One
	// 2. Two
	// 3. Three
	// 4. none
	// Choose a number (4):
	var chosenFooOptional *string
	err = interact.NewInteraction(
		"Choose a number",
		interact.Choice{Display: "One", Value: &numbers[0]},
		interact.Choice{Display: "Two", Value: &numbers[1]},
		interact.Choice{Display: "Three", Value: &numbers[2]},
		interact.Choice{Display: "none", Value: nil},
	).Resolve(&chosenFooOptional)
	if err != nil {
		fatal(err)
	}

	fmt.Println(chosenFooOptional)

	// Username:
	var username string
	err = interact.NewInteraction("Username").Resolve(interact.Required(&username))
	if err != nil {
		fatal(err)
	}

	fmt.Println(username)

	// Password:
	var password interact.Password
	err = interact.NewInteraction("Password").Resolve(interact.Required(&password))
	if err != nil {
		fatal(err)
	}

	fmt.Println(password)

	// Interrupt:
	var ctrlCTest string
	err = interact.NewInteraction("Interrupt").Resolve(interact.Required(&ctrlCTest))
	if err != nil {
		fmt.Println(err)
	}
}
Example #2
0
				ExpectedOutput: "some prompt (): \n",
			}),

			Entry("when a blank line is entered, followed by EOF", Example{
				Prompt: "some prompt",

				Input: "\n",

				ExpectedAnswer: interact.Password(""),
				ExpectedOutput: "some prompt (): \n",
			}),
		)

		Context("when required", func() {
			BeforeEach(func() {
				destination = interact.Required(destination)
			})

			DescribeTable("Resolve", (Example).Run,
				Entry("when a string is entered", Example{
					Prompt: "some prompt",

					Input: "forty two\n",

					ExpectedAnswer: interact.Password("forty two"),
					ExpectedOutput: "some prompt: \n",
				}),

				Entry("when a blank line is entered, followed by EOF", Example{
					Prompt: "some prompt",
Example #3
0
File: login.go Project: zankich/fly
func (command *LoginCommand) loginWith(method atc.AuthMethod, connection concourse.Connection) error {
	var token atc.AuthToken

	switch method.Type {
	case atc.AuthTypeOAuth:
		fmt.Println("navigate to the following URL in your browser:")
		fmt.Println("")
		fmt.Printf("    %s\n", method.AuthURL)
		fmt.Println("")

		for {
			var tokenStr string

			err := interact.NewInteraction("enter token").Resolve(interact.Required(&tokenStr))
			if err != nil {
				return err
			}

			segments := strings.SplitN(tokenStr, " ", 2)
			if len(segments) != 2 {
				fmt.Println("token must be of the format 'TYPE VALUE', e.g. 'Bearer ...'")
				continue
			}

			token.Type = segments[0]
			token.Value = segments[1]

			break
		}

	case atc.AuthTypeBasic:
		var username string
		err := interact.NewInteraction("username").Resolve(interact.Required(&username))
		if err != nil {
			return err
		}

		var password interact.Password
		err = interact.NewInteraction("password").Resolve(interact.Required(&password))
		if err != nil {
			return err
		}

		newUnauthedClient, err := rc.NewConnection(connection.URL(), command.Insecure)
		if err != nil {
			return err
		}

		basicAuthClient, err := concourse.NewConnection(
			newUnauthedClient.URL(),
			&http.Client{
				Transport: basicAuthTransport{
					username: username,
					password: string(password),
					base:     newUnauthedClient.HTTPClient().Transport,
				},
			},
		)
		if err != nil {
			return err
		}

		client := concourse.NewClient(basicAuthClient)

		token, err = client.AuthToken()
		if err != nil {
			return err
		}
	}

	err := rc.SaveTarget(
		Fly.Target,
		connection.URL(),
		command.Insecure,
		&rc.TargetToken{
			Type:  token.Type,
			Value: token.Value,
		},
	)
	if err != nil {
		return err
	}

	fmt.Println("token saved")

	return nil
}
Example #4
0
func (command *LoginCommand) loginWith(method atc.AuthMethod, client concourse.Client) error {
	var token atc.AuthToken

	switch method.Type {
	case atc.AuthTypeOAuth:
		fmt.Println("navigate to the following URL in your browser:")
		fmt.Println("")
		fmt.Printf("    %s\n", method.AuthURL)
		fmt.Println("")

		for {
			var tokenStr string

			err := interact.NewInteraction("enter token").Resolve(interact.Required(&tokenStr))
			if err != nil {
				return err
			}

			segments := strings.SplitN(tokenStr, " ", 2)
			if len(segments) != 2 {
				fmt.Println("token must be of the format 'TYPE VALUE', e.g. 'Bearer ...'")
				continue
			}

			token.Type = segments[0]
			token.Value = segments[1]

			break
		}

	case atc.AuthTypeBasic:
		var username string
		if command.Username != "" {
			username = command.Username
		} else {
			err := interact.NewInteraction("username").Resolve(interact.Required(&username))
			if err != nil {
				return err
			}
		}

		var password string
		if command.Password != "" {
			password = command.Password
		} else {
			var interactivePassword interact.Password
			err := interact.NewInteraction("password").Resolve(interact.Required(&interactivePassword))
			if err != nil {
				return err
			}
			password = string(interactivePassword)
		}

		newUnauthedClient := rc.NewUnauthenticatedClient(client.URL(), command.Insecure)

		basicAuthClient := concourse.NewClient(
			newUnauthedClient.URL(),
			&http.Client{
				Transport: basicAuthTransport{
					username: username,
					password: password,
					base:     newUnauthedClient.HTTPClient().Transport,
				},
			},
		)

		var err error
		token, err = basicAuthClient.AuthToken()
		if err != nil {
			return err
		}
	}

	return command.saveTarget(
		client.URL(),
		&rc.TargetToken{
			Type:  token.Type,
			Value: token.Value,
		},
	)
}