mise

type DotfilesStep ¶

type DotfilesStep struct {
	Runner     Runner
	Plan       *resolve.Plan
	ConfigPath string
	Yes        bool
}

DotfilesStep runs mise dotfiles apply for the dotfiles in the resolved plan.

func (s *DotfilesStep) Name() string

func (s *DotfilesStep) Run(ctx context.Context) error

type DotfilesSystemStep ¶ added in v0.2.0

type DotfilesSystemStep struct {
	Exec       *ExecMise
	Entries    []resolve.DotfileEntry
	ConfigPath string
	Yes        bool
}

DotfilesSystemStep applies system-scope dotfile entries with root privileges. It takes the concrete ExecMise (like HooksStep) because the sudo-aware entry point is deliberately not part of the Runner interface. cmd/apply.go only constructs it when at least one system-scope entry exists; Run also no-ops on an empty list as a second line of defense.

func (s *DotfilesSystemStep) Name() string

func (s *DotfilesSystemStep) Run(ctx context.Context) error

type ExecMise ¶

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

ExecMise wraps a Mise value so it can be used as a Runner by step code.

func NewExecMise(m *Mise) *ExecMise

func (e *ExecMise) DotfilesApply(ctx context.Context, configPath string, yes bool) error

func (e *ExecMise) DotfilesApplySudo(ctx context.Context, configPath string, yes bool) error

func (e *ExecMise) EnsureAndInstall(ctx context.Context, configPath string) error

func (e *ExecMise) RunTask(ctx context.Context, configPath, taskName string) error

type FakeRunner ¶

type FakeRunner struct {
	InstallCalled  bool
	DotfilesCalled bool
	Yes            bool
	Err            error
}

FakeRunner records mise invocations for tests.

func (f *FakeRunner) DotfilesApply(ctx context.Context, configPath string, yes bool) error

func (f *FakeRunner) EnsureAndInstall(ctx context.Context, configPath string) error

type HooksStep ¶

type HooksStep struct {
	Exec       *ExecMise
	Commands   []string
	ConfigPath string
	Task       string // mise task name, e.g. "hooks:pre"
	StepName   string // pipeline step name, e.g. "hooks-pre"
}

HooksStep runs one pre/post hook command list as a mise task from the// generated apply config. cmd/apply.go only constructs HooksSteps for non-empty command lists; Run also no-ops on an empty list as a second line of defense.

func (s *HooksStep) Name() string

func (s *HooksStep) Run(ctx context.Context) error

type InstallKind ¶

type InstallKind int

InstallKind classifies how a mise binary is managed.

const (
	InstallKindUnknown InstallKind = iota
	InstallKindSystemWide
	InstallKindUserManaged
)

func ClassifyInstall(path string) InstallKind

func (k InstallKind) String() string

type Mise ¶

type Mise struct {
	LookPath   func(string) (string, error)
	Run        func(string, ...string) (string, error)
	RunContext func(context.Context, string, ...string) (string, error)
	Install    func() (string, error)
	Classify   func(string) InstallKind

	// Env is extra environment ("KEY=value") appended to the subprocess
	// environment on the real exec path; fakes (Run/RunContext) bypass it.
	Env []string
	// contains filtered or unexported fields
}

Mise finds, installs, or upgrades a mise binary.

RunContext is preferred over the legacy Run; both are kept so existing fakes that only set Run keep working. The result of the first Ensure call is memoized for the lifetime of the struct.

func DefaultMise() *Mise

func (m *Mise) Ensure() (string, error)

func (m *Mise) EnsureContext(ctx context.Context) (string, error)

type Runner ¶

type Runner interface {
	EnsureAndInstall(ctx context.Context, configPath string) error
	DotfilesApply(ctx context.Context, configPath string, yes bool) error
}

Runner abstracts mise operations used by apply steps.

type ToolsStep ¶

type ToolsStep struct {
	Runner     Runner
	Plan       *resolve.Plan
	ConfigPath string
}

ToolsStep runs mise install for the tools in the resolved plan.

func (s *ToolsStep) Name() string

func (s *ToolsStep) Run(ctx context.Context) error