boil

type Action struct {
	// Description is the description text of the Action. It's an optional text
	// that should describe the action purpose.
	Description string `json:"description,omitempty"`
	// Program is the path to executable to run.
	Program string `json:"program,omitempty"`
	// Arguments are the arguments to pass to the executable.
	Arguments []string `json:"arguments,omitempty"`
	// WorkDir is the working directory to run the Program from.
	WorkDir string `json:"workDir,omitempty"`
	// Environment is the additional values to set in the Program environment.
	Environment map[string]string `json:"environment,omitempty"`
	// NoFail, if true will not break the execution of the process that ran
	// the Action, but it will generate a warning in the output.
	NoFail bool `json:"noFail,omitempty"`
}

type Actions []*Action

type Author struct {
	// Name is the author name in an arbitrary format.
	Name string `json:"name,omitempty"`
	// Email is the author Email address.
	Email string `json:"email,omitempty"`
	// Homepage is the author's homepage URL.
	Homepage string `json:"homepage,omitempty"`
	// ModulePrefix is the authors default module prefix, your repo home.
	ModulePrefix string `json:"modulePrefix,omitempty"`
}

type Config struct {
	// Author is the default template author info.
	Author Author `json:"author,omitempty"`
	// RepositoryPath is the absolute path to the default repository.
	RepositoryPath string `json:"repositoryPath"`

	// DisableBackup, if true disables output directory backup before
	// Template execution.
	//
	// If backup is disabled, if errors occur during template execution
	// the output directory might contain an incomplete and invalid output.
	DisableBackup bool `json:"disableBackup"`

	// Editor defines the action to execute for the "edit" command, i.e.
	// an external application to edit the template files and metafile.
	//
	// If no editor is defined Boil opens the Template directory in the default
	// system file explorer.
	Editor Action `json:"editor,omitempty"`

	// Overrides are the configuration overrides specified on command line.
	// They exist at runtime only and are not serialized with Config.
	Overrides struct {
		// ConfigFile is the absolute path of loaded config file.
		ConfigFile string
		// RepositoryPath is the absolute path of loaded repository.
		RepositoryPath string
		// DisableBackup overrides the Configuration.DisableBackup.
		DisableBackup bool
		// NoRepository if true does not use a repository when interpreting template
		// paths. Relative paths will be treated as relative to current working
		// directory.
		NoRepository bool
		// Verbose specifies wether to enable verbose output.
		Verbose bool
	} `json:"-"`

	// Runtime holds the runtime variables.
	// They are set by Command Run functions.
	// They exist at runtime only and are not serialized with Config.
	Runtime struct {
		// LoadedConfigFile is the name of the configuration file last loaded
		// into self using self.LoadFromFile.
		LoadedConfigFile string
	} `json:"-"`
}

type Data struct {
	Vars Variables
	Bast *bast.Bast
	Json map[string]any
}

type DiskRepository struct {
	// contains filtered or unexported fields
}

type Editor struct {
	*Interrogator
	// contains filtered or unexported fields
}

type FuncMapper interface {
	FuncMap() template.FuncMap
}

type Group struct {
	// Name is the name of the Template Group.
	Name string `json:"name,omitempty"`
	// Description is the Group description text.
	Description string `json:"description,omitempty"`
	// Templates is a slice of Template names contained in this Group.
	Templates []string `json:"templates,omitempty"`
}

type Interrogator struct {
	// contains filtered or unexported fields
}

type Metafile struct {
	// Name is the Template name.
	// It is the last element of the template path when addressing it.
	// For example 'apps/<name>'
	Name string `json:"name,omitempty"`

	// Description is the Template description.
	// It is presented to the user when asking for template information.
	Description string `json:"description,omitempty"`

	// Author is the template author details.
	// This information is optional and is generated from the values set in
	// Configuration when generating a Template.
	Author *Author `json:"author,omitempty"`

	// Version is the template version, set manually used to help keep track of
	// Template changes. SemVer will be understood if this becomes important to
	// machine; currently just a meta field possibly useful to user.
	// By default the version is set at '1.0.0' when generating a Template.
	Version string `json:"version,omitempty"`

	// URL is an optional template url. Like Version, it has no meaning to the
	// machine but is just an additional meta field. It is empty by default.
	URL string `json:"url,omitempty"`

	// Files is a list of paths to files inside the Template directory that
	// will get executed and written to the output target directory retaining
	// its path relative to the Template directory.
	//
	// Paths must be relative to the Template directory and may not be rooted.
	// Files must point to existing files inside the Template directory.
	//
	// Directories for files will be created as needed, regardless of wether
	// they are defined in Directories.
	//
	// Paths of files defined in Files may contain placeholder values which will
	// get expended to actual values during Template execution.
	// A placeholder is defined with a "$" prefix, immediately followed by the
	// name of a Variable.
	Files []string `json:"files"`

	// Directories is a list of directories to create in the target directory.
	// Placeholders are supported like with Files. Directories defined in this
	// list will be created regardless of wether they contain any of the
	// files defined by Files or if they exist phisically in the Template
	// directory. They will be created in the template however when creating a
	// Template with the "snap" command.
	Directories []string `json:"directories"`

	// Prompts is a list of prompts to present to the user before Template
	// execution via stdin to input values for variables the prompts define.
	//
	// Along with manually defining variables with the --var flag, a Template
	// can prompt the user for specific variables that the Template file needs.
	//
	// Prompts can each define a regular expression to use for input validation.
	// A failed validation will then re-prompt the user for value.
	Prompts Prompts `json:"prompts,imitempty"`

	// Actions are groups of definitions of external actions to perform at
	// various stages of Template execution. In each Action group
	// (PreParse, PreExecute,...) the name of the Action must be unique and not
	// empty.
	Actions struct {
		// PreParse is a slice of actions to perform before any input variables
		// were parsed from any of sources defined on command line, in the
		// order they are defined. This is useful for a template setup like
		// temporary file generation, data input to variables, etc.
		//
		// No placeholders are available to expand in PerParse action
		// definition and any placeholder values found in the Action definition
		// will be unchanged and passed as defined, without raising an error.
		PreParse Actions `json:"preParse,omitempty"`
		// PreExecute is a slice of actions to perform before the template is
		// executed in the order they are defined. It is called after the
		// variables were defined by parsing command line input, files given as
		// variable data on command line and all other input methods and are
		// available as expandable placeholders in action definition.
		//
		// This useful to execute some Template setup commands that depend on
		// Template variables.
		PreExecute Actions `json:"preExecute,omitempty"`

		// PostExecute is a slice of actions to perform after the template was
		// executed, in order they are defined. This is useful for performing
		// cleanup operations. Variables will be available for expansion in the
		// action definition via placeholders.
		PostExecute Actions `json:"postExecute,omitempty"`
	} `json:"actions,omitempty"`

	// Groups is a slice of Template Group definitions that may be executed
	// with the Template the metafile describes, as part of that Template.
	//
	// If the Template that this metafile describes contains other Templates
	// in any of its subdirectories, at any depths, one or more of those child
	// Templates may be combined into a named Group and addressed from it by a
	// path relative to this template.
	//
	// A Group can be executed along with the Template that defines it as part
	// of that template. This allows for defining segmented and multilayered
	// permutations of templates organized in a parent-child manner.
	//
	// A Group template is addressed by its path in a manner that the last
	// element of the path that matches Metafile.Name is instead replaced with
	// the name of the Group. So for instance, if a template 'apps/versatileapp'
	// defines groups 'base', and 'complete', to execute the 'base' Group the
	// path would be 'apps/base'.
	Groups []*Group `json:"groups,omitempty"`

	// Path is where metafile resides, relative to the repository root.
	// it is equal to template Path minus the optional group name.
	//
	// Path is not stored with the template, it's runtime only.
	Path string `json:"-"`
}

type Metamap map[string]*Metafile

type Printer struct {
	// contains filtered or unexported fields
}

type Prompt struct {
	// Variable is the name of the Variable this prompt will ask value for.
	Variable string `json:"variable,omitempty"`
	// Description is the prompt text presented to the user when asking for value.
	//
	// On stdin the format will be: "Enter a value for <Description>".
	Description string `json:"description,omitempty"`
	// RegEx is the regular expression to use to validate the input string.
	// If RegEx is not set no validation will be performed on input in addition
	// to an empty value being accepted as a value.
	RegExp string `json:"regexp,omitempty"`
	// Optional if true will not trigger an error if the variable was assigned
	// an empty value.
	Optional bool `json:"optional,omitempty"`
}

type Prompts []*Prompt

type Repository interface {
	// Location returns the repository location in a format specific to
	// Repository backend.
	Location() string

	// LoadMetamap loads metadata from repository walking all child
	// subdirectories and returns it or returns a descriptive error.
	//
	// The resulting Metamap will contain a *Metadata for each subdirectory at
	// any level in the Repository that contains a Metafile, i.e. defines a
	// Template, under a key that will be a path relative to Repository.
	//
	// If the root of the Repository contains Metafile i.e. is a Template
	// itself an entry for it will be set under current directory dot ".".
	//
	// Any groups defined in a template will be added under the same path as the
	// template that defines them but with a group name suffix prefixed with a
	// "#". For example if a template 'go/app' defines a 'config' group it would
	// be addressed as 'go/app#config'.
	LoadMetamap() (Metamap, error)
	// HasMeta returns true if path contains a metafile or an error.
	HasMeta(path string) (bool, error)
	// OpenMeta returns a *Metafile at path or an error if it does not exist or
	// some other error occurs.
	OpenMeta(path string) (*Metafile, error)
	// SaveMeta saves the Metafile into repository according to its Path or
	// returns an error. It overwrites the target if it exists or creates it if
	// it does not. Creates required directories along the path.
	SaveMeta(meta *Metafile) error

	// Exists returns true if file or dir exists at path or an error.
	Exists(path string) (bool, error)
	// GetFile gets contents of the file at path. It must exist and be
	// referenced in meta.
	ReadFile(path string) ([]byte, error)
	// WriteFile writes data as contents of the file at path into repository.
	// File may exists and if it does will be truncated and overwritten.
	// Path must be referenced in meta. Directories will be created as needed
	// if the file is referenced in meta.
	WriteFile(path string, data []byte) error
	// Mkdir creates all directories along the path or returns an error.
	Mkdir(path string) error
	// Remove removes file at path if path points to a file or recusrsively
	// deletes all content in the directory at path, recusrively. Returns an
	// error if one occured.
	Remove(path string) error

	// WalkDir walks the repository depth first and calls f for each file or
	// directory found in the repository. Behaves exactly like filepath.WalkDir
	// except that the path given to f will be a path relative to the repository
	// root.
	WalkDir(root string, f fs.WalkDirFunc) error
}

type Variable int

type Variables map[string]any