mllint

type BasicRunnerProgress ¶

type BasicRunnerProgress struct {
	Out io.Writer
}

func (p *BasicRunnerProgress) AllTasksDone()

func (p *BasicRunnerProgress) CompletedTask(task *RunnerTask)

func (p *BasicRunnerProgress) RunningTask(task *RunnerTask)

func (p *BasicRunnerProgress) Start()

func (p *BasicRunnerProgress) TaskAwaiting(task *RunnerTask)

func (p *BasicRunnerProgress) TaskResuming(task *RunnerTask)

type ConfigurableLinterWithRunner ¶

type ConfigurableLinterWithRunner interface {
	api.ConfigurableLinter
	WithRunner
}

type LinterResult ¶

type LinterResult struct {
	api.Report
	Err error
}

LinterResult represents the two-valued return type of a Linter, containing a report and an error.

type LinterWithRunner ¶

type LinterWithRunner interface {
	api.Linter
	WithRunner
}

type LiveRunnerProgress ¶

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

LiveRunnerProgress is used by an `mllint.Runner` to keep track of and pretty-print the progress of the runner in running its tasks.

Unless you're changing the implementation of `mllint.Runner`, you probably don't need to interact with this.

func (p *LiveRunnerProgress) AllTasksDone()

func (p *LiveRunnerProgress) CompletedTask(task *RunnerTask)

func (p *LiveRunnerProgress) RunningTask(task *RunnerTask)

func (p *LiveRunnerProgress) Start()

func (p *LiveRunnerProgress) TaskAwaiting(task *RunnerTask)

func (p *LiveRunnerProgress) TaskResuming(task *RunnerTask)

type MLLintRunner ¶

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

Runner implements a parallel linter runner for mllint. Use `r := NewRunner()` to create a runner, then call r.Start() on it (and defer r.Close()) to start a queue worker process that will watch for incoming tasks to run a linter, as added to the queue by calls to r.RunLinter().

The Runner will ensure that all tasks added to its queue are executed, run in parallel across all `runtime.NumCPU()` available logical cores (CPU threads, aka the amount of bars you see in `htop` :P). No more than this number of tasks will be running in parallel, any additional tasks are parked and executed as running tasks complete.

`r.RunLinter()` returns a *RunnerTask, use `result := <-task.Result` to await the completion of the linter task and receive the result of the task.

Alternatively, if you have a list of tasks to await and want to receive their results as soon as each completes, use `mllint.CollectTasks(tasks...)` to get a channel where each completed task will be sent. A task you receive through this channel will have a `LinterResult` in the `task.Result`'s buffer, so `<-task.Result` will not block. The channel closes once all tasks have completed.

Example usage with `mllint.ForEachTask()`:

```go

mllint.ForEachTask(mllint.CollectTasks(tasks...), func(task *RunnerTask, result LinterResult) {
  // do something with the completed task and its result
})

```

func NewMLLintRunner(progress RunnerProgress) *MLLintRunner

func (r *MLLintRunner) Close()

func (r *MLLintRunner) CollectTasks(tasks ...*RunnerTask) chan *RunnerTask

func (r *MLLintRunner) RunLinter(id string, linter api.Linter, project api.Project, options ...TaskOption) *RunnerTask

func (r *MLLintRunner) Start()

type Runner ¶

type Runner interface {
	RunLinter(id string, linter api.Linter, project api.Project, options ...TaskOption) *RunnerTask
	CollectTasks(tasks ...*RunnerTask) chan *RunnerTask
}

type RunnerProgress ¶

type RunnerProgress interface {
	Start()
	RunningTask(task *RunnerTask)
	TaskAwaiting(task *RunnerTask)
	TaskResuming(task *RunnerTask)
	CompletedTask(task *RunnerTask)
	AllTasksDone()
}

func NewBasicRunnerProgress() RunnerProgress

func NewLiveRunnerProgress() RunnerProgress

type RunnerTask ¶

type RunnerTask struct {
	Id      string
	Linter  api.Linter
	Project api.Project
	Result  chan LinterResult
	// contains filtered or unexported fields
}

RunnerTask represents a task to run a linter on a project that was created by a call to runner.RunLinter(...)

type TaskOption ¶

type TaskOption func(task *RunnerTask)

TaskOption is an option for a task created by RunLinter, e.g. setting a custom display name.

func DisplayName(name string) TaskOption

type WithRunner ¶

type WithRunner interface {
	SetRunner(runner Runner)
}