commands

Documentation

Index

• Constants
• Variables
• func ApplyAction(ctx *cli.Context) error
• func InitializeAction(ctx *cli.Context) error
• func InterpolateAction(ctx *cli.Context) error
• type ApplyCommand
  • func (cmd *ApplyCommand) Execute() error
• type ApplyOptions
• type InitializeCommand
  • func (cmd *InitializeCommand) Execute() error
• type InitializeOptions
• type InterpolateCommand
  • func (cmd *InterpolateCommand) Execute() error
• type InterpolateOptions

Constants

const (
	ApplyTemplateFlag = "template"
	ApplyNameFlag     = "name"
	ApplyOutFlag      = "out"
	ApplyVarFlag      = "var"
	ApplyVarFileFlag  = "var-file"
)

const (
	InterpolateTemplateFlag = "template"
	InterpolateNameFlag     = "name"
	InterpolateVarFlag      = "var"
	InterpolateVarFileFlag  = "var-file"
)

const (
	InitializeTemplateFlag = "template"
)

Variables

var Apply = &cli.Command{
	Name:        "apply",
	Description: "applies the specified template to the target directory",
	Usage:       "Applies the specified template to the target directory",
	UsageText:   "caster apply [-t|--template <TEMPLATEDIR|TEMPLATEFILE>] [-n|--name <TEMPLATENAME>] [OUTDIR]",
	Action:      ApplyAction,
	Flags: []cli.Flag{
		&cli.StringFlag{
			Name:    ApplyTemplateFlag,
			Aliases: []string{"t"},
			Value:   ".caster.yml",
		},
		&cli.StringFlag{
			Name:    ApplyNameFlag,
			Aliases: []string{"n"},
		},
		&cli.StringSliceFlag{
			Name: ApplyVarFlag,
		},
		&cli.StringSliceFlag{
			Name:      ApplyVarFileFlag,
			TakesFile: true,
		},
	},
}

var Initialize = &cli.Command{
	Name:        "initialize",
	Aliases:     []string{"init"},
	Description: "initializes the speified directory or file with the default template",
	Usage:       "initializes the speified directory or file with the default template",
	UsageText:   "caster init [DIRECTORY|FIILE]",
	Action:      InitializeAction,
	Flags: []cli.Flag{
		&cli.StringFlag{
			Name:    InitializeTemplateFlag,
			Aliases: []string{"t"},
			Value:   ".",
		},
	},
}

var Interpolate = &cli.Command{
	Name:        "interpolate",
	Aliases:     []string{"inter"},
	Description: "interpolates the specified template and outputs the result",
	Usage:       "interpolates the specified template and outputs the result",
	UsageText:   "caster interpolate [-t|--template <TEMPLATEDIR|TEMPLATEFILE>] [-n|--name <TEMPLATENAME>]",
	Action:      InterpolateAction,
	Flags: []cli.Flag{
		&cli.StringFlag{
			Name:    InterpolateTemplateFlag,
			Aliases: []string{"t"},
			Value:   ".",
		},
		&cli.StringFlag{
			Name:    InterpolateNameFlag,
			Aliases: []string{"n"},
		},
		&cli.StringSliceFlag{
			Name: InterpolateVarFlag,
		},
		&cli.StringSliceFlag{
			Name:      InterpolateVarFileFlag,
			TakesFile: true,
		},
	},
}

Functions

func ApplyAction

func ApplyAction(ctx *cli.Context) error

func InitializeAction

func InitializeAction(ctx *cli.Context) error

func InterpolateAction

func InterpolateAction(ctx *cli.Context) error

Types

type ApplyCommand

type ApplyCommand struct {
	Options     ApplyOptions
	Environment env.Environment `inject:""`
	Service     cast.Service    `inject:""`
}

func (*ApplyCommand) Execute

func (cmd *ApplyCommand) Execute() error

type ApplyOptions

type ApplyOptions struct {
	Template  string
	Name      string
	Target    string
	Variables []models.Variable
}

type InitializeCommand

type InitializeCommand struct {
	Options InitializeOptions
	Service initialize.Service `inject:""`
}

func (*InitializeCommand) Execute

func (cmd *InitializeCommand) Execute() error

type InitializeOptions

type InitializeOptions struct {
	Template string
}

type InterpolateCommand

type InterpolateCommand struct {
	Options     InterpolateOptions
	Environment env.Environment     `inject:""`
	Service     interpolate.Service `inject:""`
	Console     console.Console     `inject:""`
}

func (*InterpolateCommand) Execute

func (cmd *InterpolateCommand) Execute() error

type InterpolateOptions

type InterpolateOptions struct {
	Template  string
	Name      string
	Variables []models.Variable
}