staged

type Config ¶ added in v0.6.0

type Config struct {
	// Generated are repository-relative paths copied from the working tree into
	// the sandbox after the index is materialised.
	//
	// Every one of them must be untracked. A tracked path has an index version,
	// and letting the working tree's win is exactly the hole the sandbox exists
	// to close — so naming one here is refused rather than obeyed.
	Generated []string `json:"generated"`
}

Config is what a repository tells ditto about itself.

There is exactly one thing to say, and it exists because of one honest gap: a sandbox is built from the index, and some repositories do not build from their index alone. A generated directory the build needs — an embedded frontend bundle, generated bindings — is on disk and not in git, so the sandbox arrives without it and the package that needs it cannot compile.

Reading the index is not the part to give up: it is what makes a verdict about the change rather than about the desk it was written on, measured at 7 of 8 verdicts moving when a release read the worktree instead. So this does not widen what is read. It names, one path at a time, what git does not carry.

type OSRunner ¶

type OSRunner struct{}

OSRunner runs processes with the inherited git addressing removed.

func (OSRunner) Output(dir, name string, args ...string) ([]byte, error)

type Range ¶

type Range struct {
	Start int
	End   int
}

Range is a half-open byte span within one file, counted from its first byte.

type Repository ¶

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

Repository is a checkout the staged questions can be asked of.

func New(runner Runner, directory string) (*Repository, error)

func (r *Repository) CopyGenerated(sandbox *Sandbox, generated []string) ([]string, error)

func (r *Repository) Files(excludedPrefixes []string) ([]string, error)

func (r *Repository) LoadConfig() (Config, error)

func (r *Repository) Materialize() (*Sandbox, error)

func (r *Repository) RejectPartial(files []string) error

func (r *Repository) Root() string

func (r *Repository) ScopeOf(files []string) (Scope, error)

type Runner ¶

type Runner interface {
	Output(dir, name string, args ...string) ([]byte, error)
}

Runner is the seam over running a process, so the git work can be tested without a repository.

type Sandbox ¶

type Sandbox struct {
	Root string
	// contains filtered or unexported fields
}

Sandbox is a checkout of the index, and the thing a release must be pointed at.

The measurement that put this here: with a release pointed at the worktree instead, and one tracked file left dirty and unstaged, seven of eight verdicts moved — 0.13 against 1.00 for the identical eight mutants of an identical file. RejectPartial does not cover it, because the file that moved them was never staged and a check over staged paths never looks at it.

`git checkout-index` also happens to be the cheap way to do it: it writes exactly the staged content and nothing else, with no second walk of the tree.

func (s *Sandbox) Close()

type Scope ¶

type Scope struct {
	Files   []string
	Ranges  map[string][]Range
	Derived bool
	Reason  string
}

Scope is what a staged change justifies mutating.

Ranges is keyed by file and stays keyed by file. A byte offset only means something against the file it was measured in, so a scope that has lost track of which file a range came from makes every file answer to every range: the mutant count then grows as the square of the file count, and the extra ones land in code no diff touched.