github
/
drone-plugin-lib
mirror of https://github.com/thegeeklab/drone-plugin-lib.git
0
0
Fork 0
Code Issues Projects Releases Wiki Activity

Simplify exported urfave flags

This commit is contained in:
Don 2019-10-10 13:36:20 -07:00
parent 294ca8c890
commit e8e8ddcb17
1 changed files with 214 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

542
pkg/urfave/urfave.go
View File

@ -24,7 +24,7 @@
// } // }
// app.Flags = append( // app.Flags = append(
// app.Flags, // app.Flags,
// urfave.CommitFlags()..., // urfave.commitFlags()...,
// ) // )
// } // }
package urfave package urfave
@ -46,25 +46,25 @@ import (
func PipelineFlags() []cli.Flag { func PipelineFlags() []cli.Flag {
flags := []cli.Flag{} flags := []cli.Flag{}
flags = append(flags, BuildFlags()...) flags = append(flags, buildFlags()...)
flags = append(flags, RepoFlags()...) flags = append(flags, repoFlags()...)
flags = append(flags, CommitFlags()...) flags = append(flags, commitFlags()...)
flags = append(flags, StageFlags()...) flags = append(flags, stageFlags()...)
flags = append(flags, StepFlags()...) flags = append(flags, stepFlags()...)
flags = append(flags, SemVerFlags()...) flags = append(flags, semVerFlags()...)
return flags return flags
} }
// PipelineFromContext creates a plugin.Pipeline from the cli.Context. // PipelineFromContext creates a plugin.Pipeline from the cli.Context.
func PipelineFromContext(ctx *cli.Context) plugin.Environment { func PipelineFromContext(ctx *cli.Context) plugin.Pipeline {
return plugin.Pipeline{ return plugin.Pipeline{
Build: BuildFromContext(ctx), Build: buildFromContext(ctx),
Repo: RepoFromContext(ctx), Repo: repoFromContext(ctx),
Commit: CommitFromContext(ctx), Commit: commitFromContext(ctx),
Stage: StageFromContext(ctx), Stage: stageFromContext(ctx),
Step: StepFromContext(ctx), Step: stepFromContext(ctx),
SemVer: SemVerFromContext(ctx), SemVer: semVerFromContext(ctx),
} }
} }
@ -73,152 +73,122 @@ func PipelineFromContext(ctx *cli.Context) plugin.Environment {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// BuildActionFlag corresponds to plugin.Build.Action. buildActionFlag = "build.action"
BuildActionFlag = "build.action" buildCreatedFlag = "build.created"
// BuildCreatedFlag corresponds to plugin.Build.Created. buildDeployToFlag = "build.deploy-to"
BuildCreatedFlag = "build.created" buildEventFlag = "build.event"
// BuildDeployToFlag corresponds to plugin.Build.DeployTo. buildFailedStagesFlag = "build.failed-stages"
BuildDeployToFlag = "build.deploy-to" buildFailedStepsFlag = "build.failed-steps"
// BuildEventFlag corresponds to plugin.Build.Event. buildFinishedFlag = "build.finished"
BuildEventFlag = "build.event" buildNumberFlag = "build.number"
// BuildFailedStagesFlag corresponds to plugin.Build.FailedStages. buildParentFlag = "build.parent"
BuildFailedStagesFlag = "build.failed-stages" buildPullRequestFlag = "build.pull-request"
// BuildFailedStepsFlag corresponds to plugin.Build.FailedSteps. buildSourceBranchFlag = "build.source-branch"
BuildFailedStepsFlag = "build.failed-steps" buildStartedFlag = "build.started"
// BuildFinishedFlag corresponds to plugin.Build.Finished. buildStatusFlag = "build.status"
BuildFinishedFlag = "build.finished" buildTagFlag = "build.tag"
// BuildNumberFlag corresponds to plugin.Build.Created. buildTargetBranchFlag = "build.target-branch"
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. // buildFlags has the cli.Flags for the plugin.Build.
func BuildFlags() []cli.Flag { func buildFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: BuildActionFlag, Name: buildActionFlag,
Usage: "build action", Usage: "build action",
EnvVar: environ.BuildActionEnvVar, EnvVar: environ.BuildActionEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildCreatedFlag, Name: buildCreatedFlag,
Usage: "build created", Usage: "build created",
EnvVar: environ.BuildCreatedEnvVar, EnvVar: environ.BuildCreatedEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildDeployToFlag, Name: buildDeployToFlag,
Usage: "build deploy to", Usage: "build deploy to",
EnvVar: environ.BuildDeployToEnvVar, EnvVar: environ.BuildDeployToEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildEventFlag, Name: buildEventFlag,
Usage: "build event", Usage: "build event",
EnvVar: environ.BuildEventEnvVar, EnvVar: environ.BuildEventEnvVar,
Hidden: true,
}, },
cli.StringSliceFlag{ cli.StringSliceFlag{
Name: BuildFailedStagesFlag, Name: buildFailedStagesFlag,
Usage: "build failed stages", Usage: "build failed stages",
EnvVar: environ.BuildFailedStagesEnvVar, EnvVar: environ.BuildFailedStagesEnvVar,
Hidden: true,
}, },
cli.StringSliceFlag{ cli.StringSliceFlag{
Name: BuildFailedStepsFlag, Name: buildFailedStepsFlag,
Usage: "build failed steps", Usage: "build failed steps",
EnvVar: environ.BuildFailedStepsEnvVar, EnvVar: environ.BuildFailedStepsEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildFinishedFlag, Name: buildFinishedFlag,
Usage: "build finished", Usage: "build finished",
EnvVar: environ.BuildFinishedEnvVar, EnvVar: environ.BuildFinishedEnvVar,
Hidden: true,
}, },
cli.IntFlag{ cli.IntFlag{
Name: BuildNumberFlag, Name: buildNumberFlag,
Usage: "build number", Usage: "build number",
EnvVar: environ.BuildNumberEnvVar, EnvVar: environ.BuildNumberEnvVar,
Hidden: true,
}, },
cli.IntFlag{ cli.IntFlag{
Name: BuildParentFlag, Name: buildParentFlag,
Usage: "build parent", Usage: "build parent",
EnvVar: environ.BuildParentEnvVar, EnvVar: environ.BuildParentEnvVar,
Hidden: true,
}, },
cli.IntFlag{ cli.IntFlag{
Name: BuildPullRequestFlag, Name: buildPullRequestFlag,
Usage: "build pull request", Usage: "build pull request",
EnvVar: environ.BuildPullRequestEnvVar, EnvVar: environ.BuildPullRequestEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildSourceBranchFlag, Name: buildSourceBranchFlag,
Usage: "build source branch", Usage: "build source branch",
EnvVar: environ.BuildSourceBranchEnvVar, EnvVar: environ.BuildSourceBranchEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildStartedFlag, Name: buildStartedFlag,
Usage: "build started", Usage: "build started",
EnvVar: environ.BuildStartedEnvVar, EnvVar: environ.BuildStartedEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildStatusFlag, Name: buildStatusFlag,
Usage: "build status", Usage: "build status",
EnvVar: environ.BuildStatusEnvVar, EnvVar: environ.BuildStatusEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildTagFlag, Name: buildTagFlag,
Usage: "build tag", Usage: "build tag",
EnvVar: environ.BuildTagEnvVar, EnvVar: environ.BuildTagEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: BuildTargetBranchFlag, Name: buildTargetBranchFlag,
Usage: "build target branch", Usage: "build target branch",
EnvVar: environ.BuildTargetBranchEnvVar, EnvVar: environ.BuildTargetBranchEnvVar,
Hidden: true,
}, },
} }
} }
// BuildFromContext creates a plugin.Build from the cli.Context. // buildFromContext creates a plugin.Build from the cli.Context.
func BuildFromContext(ctx *cli.Context) plugin.Build { func buildFromContext(ctx *cli.Context) plugin.Build {
return plugin.Build{ return plugin.Build{
Action: ctx.String(BuildActionFlag), Action: ctx.String(buildActionFlag),
Created: time.Unix(ctx.Int64(BuildCreatedFlag), 0), Created: time.Unix(ctx.Int64(buildCreatedFlag), 0),
DeployTo: ctx.String(BuildDeployToFlag), DeployTo: ctx.String(buildDeployToFlag),
Event: ctx.String(BuildEventFlag), Event: ctx.String(buildEventFlag),
FailedStages: ctx.StringSlice(BuildFailedStagesFlag), FailedStages: ctx.StringSlice(buildFailedStagesFlag),
FailedSteps: ctx.StringSlice(BuildFailedStepsFlag), FailedSteps: ctx.StringSlice(buildFailedStepsFlag),
Finished: time.Unix(ctx.Int64(BuildFinishedFlag), 0), Finished: time.Unix(ctx.Int64(buildFinishedFlag), 0),
Number: ctx.Int(BuildNumberFlag), Number: ctx.Int(buildNumberFlag),
Parent: ctx.Int(BuildParentFlag), Parent: ctx.Int(buildParentFlag),
PullRequest: ctx.Int(BuildPullRequestFlag), PullRequest: ctx.Int(buildPullRequestFlag),
SourceBranch: ctx.String(BuildSourceBranchFlag), SourceBranch: ctx.String(buildSourceBranchFlag),
Started: time.Unix(ctx.Int64(BuildStartedFlag), 0), Started: time.Unix(ctx.Int64(buildStartedFlag), 0),
Status: ctx.String(BuildStatusFlag), Status: ctx.String(buildStatusFlag),
Tag: ctx.String(BuildTagFlag), Tag: ctx.String(buildTagFlag),
TargetBranch: ctx.String(BuildTargetBranchFlag), TargetBranch: ctx.String(buildTargetBranchFlag),
} }
} }
@ -227,98 +197,80 @@ func BuildFromContext(ctx *cli.Context) plugin.Build {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// RepoDefaultBranchFlag corresponds to plugin.Repo.DefaultBranch. repoDefaultBranchFlag = "repo.branch"
RepoDefaultBranchFlag = "repo.branch" repoFullNameFlag = "repo.full-name"
// RepoFullNameFlag corresponds to plugin.Repo.FullName. repoLinkFlag = "repo.link"
RepoFullNameFlag = "repo.full-name" repoNameFlag = "repo.name"
// RepoLinkFlag corresponds to plugin.Repo.Link. repoOwnerFlag = "repo.owner"
RepoLinkFlag = "repo.link" repoPrivateFlag = "repo.private"
// RepoNameFlag corresponds to plugin.Repo.Name repoRemoteURLFlag = "repo.remote-url"
RepoNameFlag = "repo.name" repoSCMFlag = "repo.scm"
// RepoOwnerFlag corresponds to plugin.Repo.Owner. repoVisibilityFlag = "repo.visibility"
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 // repoFlags has the cli.Flags for the plugin.Repo
func RepoFlags() []cli.Flag { func repoFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: RepoDefaultBranchFlag, Name: repoDefaultBranchFlag,
Usage: "repo default branch", Usage: "repo default branch",
EnvVar: environ.RepoDefaultBranchEnvVar, EnvVar: environ.RepoDefaultBranchEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoFullNameFlag, Name: repoFullNameFlag,
Usage: "repo full name", Usage: "repo full name",
EnvVar: environ.RepoFullNameEnvVar, EnvVar: environ.RepoFullNameEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoLinkFlag, Name: repoLinkFlag,
Usage: "repo link", Usage: "repo link",
EnvVar: environ.RepoLinkEnvVar, EnvVar: environ.RepoLinkEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoNameFlag, Name: repoNameFlag,
Usage: "repo name", Usage: "repo name",
EnvVar: environ.RepoNameEnvVar, EnvVar: environ.RepoNameEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoOwnerFlag, Name: repoOwnerFlag,
Usage: "repo owner", Usage: "repo owner",
EnvVar: environ.RepoOwnerEnvVar, EnvVar: environ.RepoOwnerEnvVar,
Hidden: true,
}, },
cli.BoolFlag{ cli.BoolFlag{
Name: RepoPrivateFlag, Name: repoPrivateFlag,
Usage: "repo private", Usage: "repo private",
EnvVar: environ.RepoPrivateEnvVar, EnvVar: environ.RepoPrivateEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoRemoteURLFlag, Name: repoRemoteURLFlag,
Usage: "repo remote url", Usage: "repo remote url",
EnvVar: environ.RepoRemoteURLEnvVar, EnvVar: environ.RepoRemoteURLEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoSCMFlag, Name: repoSCMFlag,
Usage: "repo scm", Usage: "repo scm",
EnvVar: environ.RepoSCMEnvVar, EnvVar: environ.RepoSCMEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: RepoVisibilityFlag, Name: repoVisibilityFlag,
Usage: "repo visibility", Usage: "repo visibility",
EnvVar: environ.RepoVisibilityEnvVar, EnvVar: environ.RepoVisibilityEnvVar,
Hidden: true,
}, },
} }
} }
// RepoFromContext creates a plugin.Repo from the cli.Context. // repoFromContext creates a plugin.Repo from the cli.Context.
func RepoFromContext(ctx *cli.Context) plugin.Repo { func repoFromContext(ctx *cli.Context) plugin.Repo {
return plugin.Repo{ return plugin.Repo{
DefaultBranch: ctx.String(RepoDefaultBranchFlag), DefaultBranch: ctx.String(repoDefaultBranchFlag),
FullName: ctx.String(RepoFullNameFlag), FullName: ctx.String(repoFullNameFlag),
Link: ctx.String(RepoLinkFlag), Link: ctx.String(repoLinkFlag),
Name: ctx.String(RepoNameFlag), Name: ctx.String(repoNameFlag),
Owner: ctx.String(RepoOwnerFlag), Owner: ctx.String(repoOwnerFlag),
Private: ctx.Bool(RepoPrivateFlag), Private: ctx.Bool(repoPrivateFlag),
RemoteURL: ctx.String(RepoRemoteURLFlag), RemoteURL: ctx.String(repoRemoteURLFlag),
SCM: ctx.String(RepoSCMFlag), SCM: ctx.String(repoSCMFlag),
Visibility: ctx.String(RepoVisibilityFlag), Visibility: ctx.String(repoVisibilityFlag),
} }
} }
@ -327,116 +279,94 @@ func RepoFromContext(ctx *cli.Context) plugin.Repo {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// CommitAfterFlag corresponds to plugin.Commit.After. commitAfterFlag = "commit.after"
CommitAfterFlag = "commit.after" commitAuthorFlag = "commit.author"
// CommitAuthorFlag corresponds to plugin.Commit.Author. commitAuthorAvatarFlag = "commit.author-avatar"
CommitAuthorFlag = "commit.author" commitAuthorEmailFlag = "commit.author-email"
// CommitAuthorAvatarFlag corresponds to plugin.Commit.AuthorAvatar. commitAuthorNameFlag = "commit.author-name"
CommitAuthorAvatarFlag = "commit.author-avatar" commitBeforeFlag = "commit.before"
// CommitAuthorEmailFlag corresponds to plugin.Commit.AuthorEmail. commitBranchFlag = "commit.branch"
CommitAuthorEmailFlag = "commit.author-email" commitLinkFlag = "commit.link"
// CommitAuthorNameFlag corresponds to plugin.Commit.AuthorName. commitMessageFlag = "commit.message"
CommitAuthorNameFlag = "commit.author-name" commitRefFlag = "commit.ref"
// CommitBeforeFlag corresponds to plugin.Commit.Before. commitSHAFlag = "commit.sha"
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. // commitFlags has the cli.Flags for the plugin.Commit.
func CommitFlags() []cli.Flag { func commitFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: CommitAfterFlag, Name: commitAfterFlag,
Usage: "commit after", Usage: "commit after",
EnvVar: environ.CommitAfterEnvVar, EnvVar: environ.CommitAfterEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitAuthorFlag, Name: commitAuthorFlag,
Usage: "commit author", Usage: "commit author",
EnvVar: environ.CommitAuthorEnvVar, EnvVar: environ.CommitAuthorEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitAuthorAvatarFlag, Name: commitAuthorAvatarFlag,
Usage: "commit author avatar", Usage: "commit author avatar",
EnvVar: environ.CommitAuthorAvatarEnvVar, EnvVar: environ.CommitAuthorAvatarEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitAuthorEmailFlag, Name: commitAuthorEmailFlag,
Usage: "commit author email", Usage: "commit author email",
EnvVar: environ.CommitAuthorEmailEnvVar, EnvVar: environ.CommitAuthorEmailEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitAuthorNameFlag, Name: commitAuthorNameFlag,
Usage: "commit author name", Usage: "commit author name",
EnvVar: environ.CommitAuthorNameEnvVar, EnvVar: environ.CommitAuthorNameEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitBeforeFlag, Name: commitBeforeFlag,
Usage: "commit before", Usage: "commit before",
EnvVar: environ.CommitBeforeEnvVar, EnvVar: environ.CommitBeforeEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitBranchFlag, Name: commitBranchFlag,
Usage: "commit branch", Usage: "commit branch",
EnvVar: environ.CommitBranchEnvVar, EnvVar: environ.CommitBranchEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitLinkFlag, Name: commitLinkFlag,
Usage: "commit link", Usage: "commit link",
EnvVar: environ.CommitLinkEnvVar, EnvVar: environ.CommitLinkEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitMessageFlag, Name: commitMessageFlag,
Usage: "commit message", Usage: "commit message",
EnvVar: environ.CommitMessageEnvVar, EnvVar: environ.CommitMessageEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitRefFlag, Name: commitRefFlag,
Usage: "commit ref", Usage: "commit ref",
EnvVar: environ.CommitRefEnvVar, EnvVar: environ.CommitRefEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: CommitSHAFlag, Name: commitSHAFlag,
Usage: "commit sha", Usage: "commit sha",
EnvVar: environ.CommitSHAEnvVar, EnvVar: environ.CommitSHAEnvVar,
Hidden: true,
}, },
} }
} }
// CommitFromContext creates a plugin.Commit from the cli.Context. // commitFromContext creates a plugin.Commit from the cli.Context.
func CommitFromContext(ctx *cli.Context) plugin.Commit { func commitFromContext(ctx *cli.Context) plugin.Commit {
return plugin.Commit{ return plugin.Commit{
After: ctx.String(CommitAfterFlag), After: ctx.String(commitAfterFlag),
Author: ctx.String(CommitAuthorFlag), Author: ctx.String(commitAuthorFlag),
AuthorAvatar: ctx.String(CommitAuthorAvatarFlag), AuthorAvatar: ctx.String(commitAuthorAvatarFlag),
AuthorEmail: ctx.String(CommitAuthorEmailFlag), AuthorEmail: ctx.String(commitAuthorEmailFlag),
AuthorName: ctx.String(CommitAuthorNameFlag), AuthorName: ctx.String(commitAuthorNameFlag),
Before: ctx.String(CommitBeforeFlag), Before: ctx.String(commitBeforeFlag),
Branch: ctx.String(CommitBranchFlag), Branch: ctx.String(commitBranchFlag),
Link: ctx.String(CommitLinkFlag), Link: ctx.String(commitLinkFlag),
Message: ctx.String(CommitMessageFlag), Message: ctx.String(commitMessageFlag),
Ref: ctx.String(CommitRefFlag), Ref: ctx.String(commitRefFlag),
SHA: ctx.String(CommitSHAFlag), SHA: ctx.String(commitSHAFlag),
} }
} }
@ -445,124 +375,98 @@ func CommitFromContext(ctx *cli.Context) plugin.Commit {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// StageArchFlag corresponds to plugin.Stage.Arch. stageArchFlag = "stage.arch"
StageArchFlag = "stage.arch" stageDependsOnFlag = "stage.depends-on"
// StageDependsOnFlag corresponds to plugin.Stage.DependsOn. stageFinishedFlag = "stage.finished"
StageDependsOnFlag = "stage.depends-on" stageKindFlag = "stage.kind"
// StageFinishedFlag corresponds to plugin.Stage.Finished. stageMachineFlag = "stage.machine"
StageFinishedFlag = "stage.finished" stageNameFlag = "stage.name"
// StageKindFlag corresponds Stage.Kind. stageNumberFlag = "stage.number"
StageKindFlag = "stage.kind" stageOSFlag = "stage.os"
// StageMachineFlag corresponds to plugin.Stage.Machine. stageStartedFlag = "stage.started"
StageMachineFlag = "stage.machine" stageStatusFlag = "stage.status"
// StageNameFlag corresponds to plugin.Stage.Name. stageTypeFlag = "stage.type"
StageNameFlag = "stage.name" stageVariantFlag = "stage.variant"
// StageNumberFlag corresponds to plugin.Stage.Number. stageVersionFlag = "stage.version"
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 // stageFlags has the cli.Flags for the plugin.Stage
func StageFlags() []cli.Flag { func stageFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: StageArchFlag, Name: stageArchFlag,
Usage: "stage arch", Usage: "stage arch",
EnvVar: environ.StageArchEnvVar, EnvVar: environ.StageArchEnvVar,
Hidden: true,
}, },
cli.StringSliceFlag{ cli.StringSliceFlag{
Name: StageDependsOnFlag, Name: stageDependsOnFlag,
Usage: "stage depends on", Usage: "stage depends on",
EnvVar: environ.StageDependsOnEnvVar, EnvVar: environ.StageDependsOnEnvVar,
Hidden: true,
}, },
cli.Int64Flag{ cli.Int64Flag{
Name: StageFinishedFlag, Name: stageFinishedFlag,
Usage: "stage finished", Usage: "stage finished",
EnvVar: environ.StageFinishedEnvVar, EnvVar: environ.StageFinishedEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageKindFlag, Name: stageKindFlag,
Usage: "stage kind", Usage: "stage kind",
EnvVar: environ.StageKindEnvVar, EnvVar: environ.StageKindEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageMachineFlag, Name: stageMachineFlag,
Usage: "stage machine", Usage: "stage machine",
EnvVar: environ.StageMachineEnvVar, EnvVar: environ.StageMachineEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageNameFlag, Name: stageNameFlag,
Usage: "stage name", Usage: "stage name",
EnvVar: environ.StageNameEnvVar, EnvVar: environ.StageNameEnvVar,
Hidden: true,
}, cli.IntFlag{ }, cli.IntFlag{
Name: StageNumberFlag, Name: stageNumberFlag,
Usage: "stage number", Usage: "stage number",
EnvVar: environ.StageNumberEnvVar, EnvVar: environ.StageNumberEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageOSFlag, Name: stageOSFlag,
Usage: "stage os", Usage: "stage os",
EnvVar: environ.StageOSEnvVar, EnvVar: environ.StageOSEnvVar,
Hidden: true,
}, cli.Int64Flag{ }, cli.Int64Flag{
Name: StageStartedFlag, Name: stageStartedFlag,
Usage: "stage started", Usage: "stage started",
EnvVar: environ.StageStartedEnvVar, EnvVar: environ.StageStartedEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageStatusFlag, Name: stageStatusFlag,
Usage: "stage status", Usage: "stage status",
EnvVar: environ.StageStatusEnvVar, EnvVar: environ.StageStatusEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageTypeFlag, Name: stageTypeFlag,
Usage: "stage type", Usage: "stage type",
EnvVar: environ.StageTypeEnvVar, EnvVar: environ.StageTypeEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageVariantFlag, Name: stageVariantFlag,
Usage: "stage variant", Usage: "stage variant",
EnvVar: environ.StageVariantEnvVar, EnvVar: environ.StageVariantEnvVar,
Hidden: true,
}, cli.StringFlag{ }, cli.StringFlag{
Name: StageVersionFlag, Name: stageVersionFlag,
Usage: "stage version", Usage: "stage version",
EnvVar: environ.StageVersionEnvVar, EnvVar: environ.StageVersionEnvVar,
Hidden: true,
}, },
} }
} }
// StageFromContext creates a plugin.Stage from the cli.Context. // stageFromContext creates a plugin.Stage from the cli.Context.
func StageFromContext(ctx *cli.Context) plugin.Stage { func stageFromContext(ctx *cli.Context) plugin.Stage {
return plugin.Stage{ return plugin.Stage{
Arch: ctx.String(StageArchFlag), Arch: ctx.String(stageArchFlag),
DependsOn: ctx.StringSlice(StageDependsOnFlag), DependsOn: ctx.StringSlice(stageDependsOnFlag),
Finished: time.Unix(ctx.Int64(StageFinishedFlag), 0), Finished: time.Unix(ctx.Int64(stageFinishedFlag), 0),
Kind: ctx.String(StageKindFlag), Kind: ctx.String(stageKindFlag),
Machine: ctx.String(StageMachineFlag), Machine: ctx.String(stageMachineFlag),
Name: ctx.String(StageNameFlag), Name: ctx.String(stageNameFlag),
Number: ctx.Int(StageNumberFlag), Number: ctx.Int(stageNumberFlag),
OS: ctx.String(StageOSFlag), OS: ctx.String(stageOSFlag),
Started: time.Unix(ctx.Int64(StageStartedFlag), 0), Started: time.Unix(ctx.Int64(stageStartedFlag), 0),
Status: ctx.String(StageStatusFlag), Status: ctx.String(stageStatusFlag),
Type: ctx.String(StageTypeFlag), Type: ctx.String(stageTypeFlag),
Variant: ctx.String(StageVariantFlag), Variant: ctx.String(stageVariantFlag),
Version: ctx.String(StageVersionFlag), Version: ctx.String(stageVersionFlag),
} }
} }
@ -571,35 +475,33 @@ func StageFromContext(ctx *cli.Context) plugin.Stage {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// StepNameFlag corresponds to plugin.Step.Name. // stepNameFlag corresponds to plugin.Step.Name.
StepNameFlag = "step.name" stepNameFlag = "step.name"
// StepNumberFlag corresponds to plugin.Step.Number. // stepNumberFlag corresponds to plugin.Step.Number.
StepNumberFlag = "step.number" stepNumberFlag = "step.number"
) )
// StepFlags has the cli.Flags for the plugin.Step. // stepFlags has the cli.Flags for the plugin.Step.
func StepFlags() []cli.Flag { func stepFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: StepNameFlag, Name: stepNameFlag,
Usage: "step name", Usage: "step name",
EnvVar: environ.StepNameEnvVar, EnvVar: environ.StepNameEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: StepNumberFlag, Name: stepNumberFlag,
Usage: "step number", Usage: "step number",
EnvVar: environ.StepNumberEnvVar, EnvVar: environ.StepNumberEnvVar,
Hidden: true,
}, },
} }
} }
// StepFromContext creates a plugin.Step from the cli.Context. // stepFromContext creates a plugin.Step from the cli.Context.
func StepFromContext(ctx *cli.Context) plugin.Step { func stepFromContext(ctx *cli.Context) plugin.Step {
return plugin.Step{ return plugin.Step{
Name: ctx.String(StepNameFlag), Name: ctx.String(stepNameFlag),
Number: ctx.Int(StepNumberFlag), Number: ctx.Int(stepNumberFlag),
} }
} }
@ -608,88 +510,72 @@ func StepFromContext(ctx *cli.Context) plugin.Step {
//--------------------------------------------------------------------- //---------------------------------------------------------------------
const ( const (
// SemVerBuildFlag corresponds to plugin.SemVer.Build. semVerBuildFlag = "semver.build"
SemVerBuildFlag = "semver.build" semVerErrorFlag = "semver.error"
// SemVerErrorFlag corresponds to plugin.SemVer.Error. semVerMajorFlag = "semver.major"
SemVerErrorFlag = "semver.error" semVerMinorFlag = "semver.minor"
// SemVerMajorFlag corresponds to plugin.SemVer.Major. semVerPatchFlag = "semver.patch"
SemVerMajorFlag = "semver.major" semVerPrereleaseFlag = "semver.prerelease"
// SemVerMinorFlag corresponds to plugin.SemVer.Minor. semVerShortFlag = "semver.short"
SemVerMinorFlag = "semver.minor" semVerVersionFlag = "semver.version"
// 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. // semVerFlags has the cli.Flags for the plugin.SemVer.
func SemVerFlags() []cli.Flag { func semVerFlags() []cli.Flag {
return []cli.Flag{ return []cli.Flag{
cli.StringFlag{ cli.StringFlag{
Name: SemVerBuildFlag, Name: semVerBuildFlag,
Usage: "semver build", Usage: "semver build",
EnvVar: environ.SemVerBuildEnvVar, EnvVar: environ.SemVerBuildEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerErrorFlag, Name: semVerErrorFlag,
Usage: "semver error", Usage: "semver error",
EnvVar: environ.SemVerErrorEnvVar, EnvVar: environ.SemVerErrorEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerMajorFlag, Name: semVerMajorFlag,
Usage: "semver major", Usage: "semver major",
EnvVar: environ.SemVerMajorEnvVar, EnvVar: environ.SemVerMajorEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerMinorFlag, Name: semVerMinorFlag,
Usage: "semver minor", Usage: "semver minor",
EnvVar: environ.SemVerMinorEnvVar, EnvVar: environ.SemVerMinorEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerPatchFlag, Name: semVerPatchFlag,
Usage: "semver patch", Usage: "semver patch",
EnvVar: environ.SemVerPatchEnvVar, EnvVar: environ.SemVerPatchEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerPrereleaseFlag, Name: semVerPrereleaseFlag,
Usage: "semver prerelease", Usage: "semver prerelease",
EnvVar: environ.SemVerPrereleaseEnvVar, EnvVar: environ.SemVerPrereleaseEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerShortFlag, Name: semVerShortFlag,
Usage: "semver short", Usage: "semver short",
EnvVar: environ.SemVerShortEnvVar, EnvVar: environ.SemVerShortEnvVar,
Hidden: true,
}, },
cli.StringFlag{ cli.StringFlag{
Name: SemVerVersionFlag, Name: semVerVersionFlag,
Usage: "semver version", Usage: "semver version",
EnvVar: environ.SemVerVersionEnvVar, EnvVar: environ.SemVerVersionEnvVar,
Hidden: true,
}, },
} }
} }
// SemVerFromContext creates a plugin.Step from the cli.Context. // semVerFromContext creates a plugin.Step from the cli.Context.
func SemVerFromContext(ctx *cli.Context) plugin.SemVer { func semVerFromContext(ctx *cli.Context) plugin.SemVer {
return plugin.SemVer{ return plugin.SemVer{
Build: ctx.String(SemVerBuildFlag), Build: ctx.String(semVerBuildFlag),
Error: ctx.String(SemVerErrorFlag), Error: ctx.String(semVerErrorFlag),
Major: ctx.String(SemVerMajorFlag), Major: ctx.String(semVerMajorFlag),
Minor: ctx.String(SemVerMinorFlag), Minor: ctx.String(semVerMinorFlag),
Patch: ctx.String(SemVerPatchFlag), Patch: ctx.String(semVerPatchFlag),
Prerelease: ctx.String(SemVerPrereleaseFlag), Prerelease: ctx.String(semVerPrereleaseFlag),
Short: ctx.String(SemVerShortFlag), Short: ctx.String(semVerShortFlag),
Version: ctx.String(SemVerVersionFlag), Version: ctx.String(semVerVersionFlag),
} }
} }