wp-plugin-go/pkg/urfave/urfave.go

// Copyright (c) 2019, the Drone Plugins project authors.
// Please see the AUTHORS file for details. All rights reserved.
// Use of this source code is governed by an Apache 2.0 license that can be
// found in the LICENSE file.

// Package urfave provides helpers for interacting with the `urfave/cli`
// package when creating plugins for use by the Drone CI/CD service.
//
// Drone communicates to plugins by passing in environment variables that have
// information on the currently executing build. The `urfave/cli` package can
// read these environment variables and extract them into structs.
//
//     import(
//         "github.com/drone-plugins/drone-plugin-lib/pkg/urfave"
//         "github.com/urfave/cli"
//	   )
//
//     func main() {
//         app := cli.New()
//         app.Name = "my awesome Drone plugin"
//         app.Run = run
//         app.Flags = []cli.Flags{
//             // All my plugin flags
//         }
//         app.Flags = append(
//             app.Flags,
//             urfave.CommitFlags()...,
//         )
//     }
package urfave

import (
	"time"

	"github.com/urfave/cli"

	"github.com/drone-plugins/drone-plugin-lib/internal/environ"
	"github.com/drone-plugins/drone-plugin-lib/pkg/plugin"
)

//---------------------------------------------------------------------
// Pipeline
//---------------------------------------------------------------------

// PipelineFlags has the cli.Flags for the plugin.Pipeline.
func PipelineFlags() []cli.Flag {
	flags := []cli.Flag{}

	flags = append(flags, BuildFlags()...)
	flags = append(flags, RepoFlags()...)
	flags = append(flags, CommitFlags()...)
	flags = append(flags, StageFlags()...)
	flags = append(flags, StepFlags()...)
	flags = append(flags, SemVerFlags()...)

	return flags
}

// PipelineFromContext creates a plugin.Pipeline from the cli.Context.
func PipelineFromContext(ctx *cli.Context) plugin.Environment {
	return plugin.Pipeline{
		Build:  BuildFromContext(ctx),
		Repo:   RepoFromContext(ctx),
		Commit: CommitFromContext(ctx),
		Stage:  StageFromContext(ctx),
		Step:   StepFromContext(ctx),
		SemVer: SemVerFromContext(ctx),
	}
}

//---------------------------------------------------------------------
// Build Flags
//---------------------------------------------------------------------

const (
	// BuildActionFlag corresponds to plugin.Build.Action.
	BuildActionFlag = "build.action"
	// BuildCreatedFlag corresponds to plugin.Build.Created.
	BuildCreatedFlag = "build.created"
	// BuildDeployToFlag corresponds to plugin.Build.DeployTo.
	BuildDeployToFlag = "build.deploy-to"
	// BuildEventFlag corresponds to plugin.Build.Event.
	BuildEventFlag = "build.event"
	// BuildFailedStagesFlag corresponds to plugin.Build.FailedStages.
	BuildFailedStagesFlag = "build.failed-stages"
	// BuildFailedStepsFlag corresponds to plugin.Build.FailedSteps.
	BuildFailedStepsFlag = "build.failed-steps"
	// BuildFinishedFlag corresponds to plugin.Build.Finished.
	BuildFinishedFlag = "build.finished"
	// BuildNumberFlag corresponds to plugin.Build.Created.
	BuildNumberFlag = "build.number"
	// BuildParentFlag corresponds to plugin.Build.Parent.
	BuildParentFlag = "build.parent"
	// BuildPullRequestFlag corresponds to plugin.Build.PullRequest.
	BuildPullRequestFlag = "build.pull-request"
	// BuildSourceBranchFlag corresponds to plugin.Build.SourceBranch.
	BuildSourceBranchFlag = "build.source-branch"
	// BuildStartedFlag corresponds to plugin.Build.Started.
	BuildStartedFlag = "build.started"
	// BuildStatusFlag corresponds to plugin.Build.Status.
	BuildStatusFlag = "build.status"
	// BuildTagFlag corresponds to plugin.Build.Tag.
	BuildTagFlag = "build.tag"
	// BuildTargetBranchFlag corresponds to plugin.Build.TargetBranch.
	BuildTargetBranchFlag = "build.target-branch"
)

// BuildFlags has the cli.Flags for the plugin.Build.
func BuildFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   BuildActionFlag,
			Usage:  "build action",
			EnvVar: environ.BuildActionEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildCreatedFlag,
			Usage:  "build created",
			EnvVar: environ.BuildCreatedEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildDeployToFlag,
			Usage:  "build deploy to",
			EnvVar: environ.BuildDeployToEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildEventFlag,
			Usage:  "build event",
			EnvVar: environ.BuildEventEnvVar,
			Hidden: true,
		},
		cli.StringSliceFlag{
			Name:   BuildFailedStagesFlag,
			Usage:  "build failed stages",
			EnvVar: environ.BuildFailedStagesEnvVar,
			Hidden: true,
		},
		cli.StringSliceFlag{
			Name:   BuildFailedStepsFlag,
			Usage:  "build failed steps",
			EnvVar: environ.BuildFailedStepsEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildFinishedFlag,
			Usage:  "build finished",
			EnvVar: environ.BuildFinishedEnvVar,
			Hidden: true,
		},
		cli.IntFlag{
			Name:   BuildNumberFlag,
			Usage:  "build number",
			EnvVar: environ.BuildNumberEnvVar,
			Hidden: true,
		},
		cli.IntFlag{
			Name:   BuildParentFlag,
			Usage:  "build parent",
			EnvVar: environ.BuildParentEnvVar,
			Hidden: true,
		},
		cli.IntFlag{
			Name:   BuildPullRequestFlag,
			Usage:  "build pull request",
			EnvVar: environ.BuildPullRequestEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildSourceBranchFlag,
			Usage:  "build source branch",
			EnvVar: environ.BuildSourceBranchEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildStartedFlag,
			Usage:  "build started",
			EnvVar: environ.BuildStartedEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildStatusFlag,
			Usage:  "build status",
			EnvVar: environ.BuildStatusEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildTagFlag,
			Usage:  "build tag",
			EnvVar: environ.BuildTagEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   BuildTargetBranchFlag,
			Usage:  "build target branch",
			EnvVar: environ.BuildTargetBranchEnvVar,
			Hidden: true,
		},
	}
}

// BuildFromContext creates a plugin.Build from the cli.Context.
func BuildFromContext(ctx *cli.Context) plugin.Build {
	return plugin.Build{
		Action:       ctx.String(BuildActionFlag),
		Created:      time.Unix(ctx.Int64(BuildCreatedFlag), 0),
		DeployTo:     ctx.String(BuildDeployToFlag),
		Event:        ctx.String(BuildEventFlag),
		FailedStages: ctx.StringSlice(BuildFailedStagesFlag),
		FailedSteps:  ctx.StringSlice(BuildFailedStepsFlag),
		Finished:     time.Unix(ctx.Int64(BuildFinishedFlag), 0),
		Number:       ctx.Int(BuildNumberFlag),
		Parent:       ctx.Int(BuildParentFlag),
		PullRequest:  ctx.Int(BuildPullRequestFlag),
		SourceBranch: ctx.String(BuildSourceBranchFlag),
		Started:      time.Unix(ctx.Int64(BuildStartedFlag), 0),
		Status:       ctx.String(BuildStatusFlag),
		Tag:          ctx.String(BuildTagFlag),
		TargetBranch: ctx.String(BuildTargetBranchFlag),
	}
}

//---------------------------------------------------------------------
// Repo Flags
//---------------------------------------------------------------------

const (
	// RepoDefaultBranchFlag corresponds to plugin.Repo.DefaultBranch.
	RepoDefaultBranchFlag = "repo.branch"
	// RepoFullNameFlag corresponds to plugin.Repo.FullName.
	RepoFullNameFlag = "repo.full-name"
	// RepoLinkFlag corresponds to plugin.Repo.Link.
	RepoLinkFlag = "repo.link"
	// RepoNameFlag corresponds to plugin.Repo.Name
	RepoNameFlag = "repo.name"
	// RepoOwnerFlag corresponds to plugin.Repo.Owner.
	RepoOwnerFlag = "repo.owner"
	// RepoPrivateFlag corresponds to plugin.Repo.Private.
	RepoPrivateFlag = "repo.private"
	// RepoRemoteURLFlag corresponds to plugin.Repo.RemoteURL.
	RepoRemoteURLFlag = "repo.remote-url"
	// RepoSCMFlag corresponds to plugin.Repo.SCM.
	RepoSCMFlag = "repo.scm"
	// RepoVisibilityFlag corresponds to plugin.Repo.Visbility.
	RepoVisibilityFlag = "repo.visibility"
)

// RepoFlags has the cli.Flags for the plugin.Repo
func RepoFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   RepoDefaultBranchFlag,
			Usage:  "repo default branch",
			EnvVar: environ.RepoDefaultBranchEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoFullNameFlag,
			Usage:  "repo full name",
			EnvVar: environ.RepoFullNameEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoLinkFlag,
			Usage:  "repo link",
			EnvVar: environ.RepoLinkEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoNameFlag,
			Usage:  "repo name",
			EnvVar: environ.RepoNameEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoOwnerFlag,
			Usage:  "repo owner",
			EnvVar: environ.RepoOwnerEnvVar,
			Hidden: true,
		},
		cli.BoolFlag{
			Name:   RepoPrivateFlag,
			Usage:  "repo private",
			EnvVar: environ.RepoPrivateEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoRemoteURLFlag,
			Usage:  "repo remote url",
			EnvVar: environ.RepoRemoteURLEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoSCMFlag,
			Usage:  "repo scm",
			EnvVar: environ.RepoSCMEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   RepoVisibilityFlag,
			Usage:  "repo visibility",
			EnvVar: environ.RepoVisibilityEnvVar,
			Hidden: true,
		},
	}
}

// RepoFromContext creates a plugin.Repo from the cli.Context.
func RepoFromContext(ctx *cli.Context) plugin.Repo {
	return plugin.Repo{
		DefaultBranch: ctx.String(RepoDefaultBranchFlag),
		FullName:      ctx.String(RepoFullNameFlag),
		Link:          ctx.String(RepoLinkFlag),
		Name:          ctx.String(RepoNameFlag),
		Owner:         ctx.String(RepoOwnerFlag),
		Private:       ctx.Bool(RepoPrivateFlag),
		RemoteURL:     ctx.String(RepoRemoteURLFlag),
		SCM:           ctx.String(RepoSCMFlag),
		Visibility:    ctx.String(RepoVisibilityFlag),
	}
}

//---------------------------------------------------------------------
// Commit Flags
//---------------------------------------------------------------------

const (
	// CommitAfterFlag corresponds to plugin.Commit.After.
	CommitAfterFlag = "commit.after"
	// CommitAuthorFlag corresponds to plugin.Commit.Author.
	CommitAuthorFlag = "commit.author"
	// CommitAuthorAvatarFlag corresponds to plugin.Commit.AuthorAvatar.
	CommitAuthorAvatarFlag = "commit.author-avatar"
	// CommitAuthorEmailFlag corresponds to plugin.Commit.AuthorEmail.
	CommitAuthorEmailFlag = "commit.author-email"
	// CommitAuthorNameFlag corresponds to plugin.Commit.AuthorName.
	CommitAuthorNameFlag = "commit.author-name"
	// CommitBeforeFlag corresponds to plugin.Commit.Before.
	CommitBeforeFlag = "commit.before"
	// CommitBranchFlag corresponds to plugin.Commit.Branch.
	CommitBranchFlag = "commit.branch"
	// CommitLinkFlag corresponds to plugin.Commit.Link.
	CommitLinkFlag = "commit.link"
	// CommitMessageFlag corresponds to plugin.Commit.Message.
	CommitMessageFlag = "commit.message"
	// CommitRefFlag corresponds to plugin.Commit.Ref.
	CommitRefFlag = "commit.ref"
	// CommitSHAFlag corresponds to plugin.Commit.SHA.
	CommitSHAFlag = "commit.sha"
)

// CommitFlags has the cli.Flags for the plugin.Commit.
func CommitFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   CommitAfterFlag,
			Usage:  "commit after",
			EnvVar: environ.CommitAfterEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitAuthorFlag,
			Usage:  "commit author",
			EnvVar: environ.CommitAuthorEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitAuthorAvatarFlag,
			Usage:  "commit author avatar",
			EnvVar: environ.CommitAuthorAvatarEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitAuthorEmailFlag,
			Usage:  "commit author email",
			EnvVar: environ.CommitAuthorEmailEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitAuthorNameFlag,
			Usage:  "commit author name",
			EnvVar: environ.CommitAuthorNameEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitBeforeFlag,
			Usage:  "commit before",
			EnvVar: environ.CommitBeforeEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitBranchFlag,
			Usage:  "commit branch",
			EnvVar: environ.CommitBranchEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitLinkFlag,
			Usage:  "commit link",
			EnvVar: environ.CommitLinkEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitMessageFlag,
			Usage:  "commit message",
			EnvVar: environ.CommitMessageEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitRefFlag,
			Usage:  "commit ref",
			EnvVar: environ.CommitRefEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   CommitSHAFlag,
			Usage:  "commit sha",
			EnvVar: environ.CommitSHAEnvVar,
			Hidden: true,
		},
	}
}

// CommitFromContext creates a plugin.Commit from the cli.Context.
func CommitFromContext(ctx *cli.Context) plugin.Commit {
	return plugin.Commit{
		After:        ctx.String(CommitAfterFlag),
		Author:       ctx.String(CommitAuthorFlag),
		AuthorAvatar: ctx.String(CommitAuthorAvatarFlag),
		AuthorEmail:  ctx.String(CommitAuthorEmailFlag),
		AuthorName:   ctx.String(CommitAuthorNameFlag),
		Before:       ctx.String(CommitBeforeFlag),
		Branch:       ctx.String(CommitBranchFlag),
		Link:         ctx.String(CommitLinkFlag),
		Message:      ctx.String(CommitMessageFlag),
		Ref:          ctx.String(CommitRefFlag),
		SHA:          ctx.String(CommitSHAFlag),
	}
}

//---------------------------------------------------------------------
// Stage Flags
//---------------------------------------------------------------------

const (
	// StageArchFlag corresponds to plugin.Stage.Arch.
	StageArchFlag = "stage.arch"
	// StageDependsOnFlag corresponds to plugin.Stage.DependsOn.
	StageDependsOnFlag = "stage.depends-on"
	// StageFinishedFlag corresponds to plugin.Stage.Finished.
	StageFinishedFlag = "stage.finished"
	// StageKindFlag corresponds Stage.Kind.
	StageKindFlag = "stage.kind"
	// StageMachineFlag corresponds to plugin.Stage.Machine.
	StageMachineFlag = "stage.machine"
	// StageNameFlag corresponds to plugin.Stage.Name.
	StageNameFlag = "stage.name"
	// StageNumberFlag corresponds to plugin.Stage.Number.
	StageNumberFlag = "stage.number"
	// StageOSFlag corresponds to plugin.Stage.OS.
	StageOSFlag = "stage.os"
	// StageStartedFlag corresponds to plugin.Stage.Started.
	StageStartedFlag = "stage.started"
	// StageStatusFlag corresponds to plugin.Stage.Status.
	StageStatusFlag = "stage.status"
	// StageTypeFlag corresponds to plugin.Stage.Type.
	StageTypeFlag = "stage.type"
	// StageVariantFlag corresponds to plugin.Stage.Variant.
	StageVariantFlag = "stage.variant"
	// StageVersionFlag corresponds to plugin.Stage.Version.
	StageVersionFlag = "stage.version"
)

// StageFlags has the cli.Flags for the plugin.Stage
func StageFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   StageArchFlag,
			Usage:  "stage arch",
			EnvVar: environ.StageArchEnvVar,
			Hidden: true,
		},
		cli.StringSliceFlag{
			Name:   StageDependsOnFlag,
			Usage:  "stage depends on",
			EnvVar: environ.StageDependsOnEnvVar,
			Hidden: true,
		},
		cli.Int64Flag{
			Name:   StageFinishedFlag,
			Usage:  "stage finished",
			EnvVar: environ.StageFinishedEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageKindFlag,
			Usage:  "stage kind",
			EnvVar: environ.StageKindEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageMachineFlag,
			Usage:  "stage machine",
			EnvVar: environ.StageMachineEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageNameFlag,
			Usage:  "stage name",
			EnvVar: environ.StageNameEnvVar,
			Hidden: true,
		}, cli.IntFlag{
			Name:   StageNumberFlag,
			Usage:  "stage number",
			EnvVar: environ.StageNumberEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageOSFlag,
			Usage:  "stage os",
			EnvVar: environ.StageOSEnvVar,
			Hidden: true,
		}, cli.Int64Flag{
			Name:   StageStartedFlag,
			Usage:  "stage started",
			EnvVar: environ.StageStartedEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageStatusFlag,
			Usage:  "stage status",
			EnvVar: environ.StageStatusEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageTypeFlag,
			Usage:  "stage type",
			EnvVar: environ.StageTypeEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageVariantFlag,
			Usage:  "stage variant",
			EnvVar: environ.StageVariantEnvVar,
			Hidden: true,
		}, cli.StringFlag{
			Name:   StageVersionFlag,
			Usage:  "stage version",
			EnvVar: environ.StageVersionEnvVar,
			Hidden: true,
		},
	}
}

// StageFromContext creates a plugin.Stage from the cli.Context.
func StageFromContext(ctx *cli.Context) plugin.Stage {
	return plugin.Stage{
		Arch:      ctx.String(StageArchFlag),
		DependsOn: ctx.StringSlice(StageDependsOnFlag),
		Finished:  time.Unix(ctx.Int64(StageFinishedFlag), 0),
		Kind:      ctx.String(StageKindFlag),
		Machine:   ctx.String(StageMachineFlag),
		Name:      ctx.String(StageNameFlag),
		Number:    ctx.Int(StageNumberFlag),
		OS:        ctx.String(StageOSFlag),
		Started:   time.Unix(ctx.Int64(StageStartedFlag), 0),
		Status:    ctx.String(StageStatusFlag),
		Type:      ctx.String(StageTypeFlag),
		Variant:   ctx.String(StageVariantFlag),
		Version:   ctx.String(StageVersionFlag),
	}
}

//---------------------------------------------------------------------
// Step Flags
//---------------------------------------------------------------------

const (
	// StepNameFlag corresponds to plugin.Step.Name.
	StepNameFlag = "step.name"
	// StepNumberFlag corresponds to plugin.Step.Number.
	StepNumberFlag = "step.number"
)

// StepFlags has the cli.Flags for the plugin.Step.
func StepFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   StepNameFlag,
			Usage:  "step name",
			EnvVar: environ.StepNameEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   StepNumberFlag,
			Usage:  "step number",
			EnvVar: environ.StepNumberEnvVar,
			Hidden: true,
		},
	}
}

// StepFromContext creates a plugin.Step from the cli.Context.
func StepFromContext(ctx *cli.Context) plugin.Step {
	return plugin.Step{
		Name:   ctx.String(StepNameFlag),
		Number: ctx.Int(StepNumberFlag),
	}
}

//---------------------------------------------------------------------
// SemVer Flags
//---------------------------------------------------------------------

const (
	// SemVerBuildFlag corresponds to plugin.SemVer.Build.
	SemVerBuildFlag = "semver.build"
	// SemVerErrorFlag corresponds to plugin.SemVer.Error.
	SemVerErrorFlag = "semver.error"
	// SemVerMajorFlag corresponds to plugin.SemVer.Major.
	SemVerMajorFlag = "semver.major"
	// SemVerMinorFlag corresponds to plugin.SemVer.Minor.
	SemVerMinorFlag = "semver.minor"
	// SemVerPatchFlag corresponds to plugin.SemVer.Patch.
	SemVerPatchFlag = "semver.patch"
	// SemVerPrereleaseFlag corresponds to plugin.SemVer.Prerelease
	SemVerPrereleaseFlag = "semver.prerelease"
	// SemVerShortFlag corresponds to plugin.SemVer.Short.
	SemVerShortFlag = "semver.short"
	// SemVerVersionFlag corresponds to plugin.SemVer.Version
	SemVerVersionFlag = "semver.version"
)

// SemVerFlags has the cli.Flags for the plugin.SemVer.
func SemVerFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:   SemVerBuildFlag,
			Usage:  "semver build",
			EnvVar: environ.SemVerBuildEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerErrorFlag,
			Usage:  "semver error",
			EnvVar: environ.SemVerErrorEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerMajorFlag,
			Usage:  "semver major",
			EnvVar: environ.SemVerMajorEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerMinorFlag,
			Usage:  "semver minor",
			EnvVar: environ.SemVerMinorEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerPatchFlag,
			Usage:  "semver patch",
			EnvVar: environ.SemVerPatchEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerPrereleaseFlag,
			Usage:  "semver prerelease",
			EnvVar: environ.SemVerPrereleaseEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerShortFlag,
			Usage:  "semver short",
			EnvVar: environ.SemVerShortEnvVar,
			Hidden: true,
		},
		cli.StringFlag{
			Name:   SemVerVersionFlag,
			Usage:  "semver version",
			EnvVar: environ.SemVerVersionEnvVar,
			Hidden: true,
		},
	}
}

// SemVerFromContext creates a plugin.Step from the cli.Context.
func SemVerFromContext(ctx *cli.Context) plugin.SemVer {
	return plugin.SemVer{
		Build:      ctx.String(SemVerBuildFlag),
		Error:      ctx.String(SemVerErrorFlag),
		Major:      ctx.String(SemVerMajorFlag),
		Minor:      ctx.String(SemVerMinorFlag),
		Patch:      ctx.String(SemVerPatchFlag),
		Prerelease: ctx.String(SemVerPrereleaseFlag),
		Short:      ctx.String(SemVerShortFlag),
		Version:    ctx.String(SemVerVersionFlag),
	}
}