statusv2

type BranchInfo ¶

type BranchInfo struct {
	OID      string // current commit hash, or "(initial)" for new repos
	Head     string // current branch name, or "(detached)" for detached HEAD
	Upstream string // upstream branch name (empty if no upstream set)
	Ahead    int    // commits ahead of upstream
	Behind   int    // commits behind upstream
}

BranchInfo contains branch information from git status --branch output.

Available when --branch flag is used. Contains current branch state, upstream tracking information, and ahead/behind commit counts.

type ChangedEntry ¶

type ChangedEntry struct {
	XY    XYFlag          // staged and unstaged XY values
	Sub   SubmoduleStatus // submodule state information
	ModeH FileMode        // file mode in HEAD commit
	ModeI FileMode        // file mode in index (staged)
	ModeW FileMode        // file mode in worktree (unstaged)
	HashH string          // object hash in HEAD commit
	HashI string          // object hash in index (staged)
	Path  string          // file path relative to repository root
}

ChangedEntry represents a modified file (added, modified, deleted, etc).

Corresponds to porcelain=v2 status lines starting with "1". Does not include renamed or copied files (see RenameOrCopyEntry).

func (ChangedEntry) Type() EntryType

type Entry ¶

type Entry interface {
	Type() EntryType
}

Entry represents a file status entry. Use type switching to access specific fields:

switch e := entry.(type) {
case ChangedEntry:
	// Access e.Path, etc.
case RenameOrCopyEntry:
	// Access e.Path, e.Orig, etc.
}

type EntryType ¶

type EntryType int

EntryType identifies the kind of file status entry.

const (
	EntryTypeChanged      EntryType = iota // "1" - modified files
	EntryTypeRenameOrCopy                  // "2" - renamed or copied files
	EntryTypeUnmerged                      // "u" - merge conflict files
	EntryTypeUntracked                     // "?" - untracked files
	EntryTypeIgnored                       // "!" - ignored files
)

type FileMode ¶

type FileMode uint32

A FileMode represents the kind of tree entries used by git. It resembles regular file systems modes, although FileModes are considerably simpler.

const (
	FileModeEmpty      FileMode = 0
	FileModeDir        FileMode = 0040000
	FileModeRegular    FileMode = 0100644
	FileModeExecutable FileMode = 0100755
	FileModeSymlink    FileMode = 0120000
	FileModeSubmodule  FileMode = 0160000
)

func (m FileMode) String() string

type IgnoredEntry ¶

type IgnoredEntry struct {
	Path string // file path relative to repository root
}

IgnoredEntry represents an ignored file.

Corresponds to git status lines starting with "!" (when --ignored is used).

func (IgnoredEntry) Type() EntryType

type RenameOrCopyEntry ¶

type RenameOrCopyEntry struct {
	XY    XYFlag          // staged and unstaged XY values
	Sub   SubmoduleStatus // submodule state information
	ModeH FileMode        // file mode in HEAD commit
	ModeI FileMode        // file mode in index (staged)
	ModeW FileMode        // file mode in worktree (unstaged)
	HashH string          // object hash in HEAD commit
	HashI string          // object hash in index (staged)
	Score string          // similarity score (e.g. "R100", "C75")
	Path  string          // new file path
	Orig  string          // original file path
}

RenameOrCopyEntry represents a renamed or copied file.

Corresponds to porcelain=v2 status lines starting with "2". Includes both the original and new file paths, plus a similarity score.

func (RenameOrCopyEntry) Type() EntryType

type StashInfo ¶

type StashInfo struct {
	Count int // number of stash entries
}

StashInfo contains stash information from git status --show-stash output.

Available when --show-stash flag is used and stashes exist.

type State ¶

type State byte

State represents a single character from Git porcelain=v2 XY status codes.

const (
	Unmodified      State = '.' // unmodified (no changes)
	Modified        State = 'M' // modified
	TypeChanged     State = 'T' // file type changed (regular file, symbolic link or submodule)
	Added           State = 'A' // added
	Deleted         State = 'D' // deleted
	Renamed         State = 'R' // renamed
	Copied          State = 'C' // copied (if status.renames=copies)
	UpdatedUnmerged State = 'U' // updated but unmerged (merge conflict)
)

type Status ¶

type Status struct {
	Branch  *BranchInfo // nil if `--branch` not passed
	Stash   *StashInfo  // nil if `--show-stash` not passed or count == 0
	Entries []Entry     // in the order lines appeared; can be ChangedEntry, RenameOrCopyEntry, UnmergedEntry, UntrackedEntry, or IgnoredEntry
}

Status represents parsed git status --porcelain=v2 output.

Branch contains branch information if --branch was used. Stash contains stash count if --show-stash was used and stashes exist. Entries contains all file status entries in the order they appeared.

func Parse(r io.Reader) (*Status, error)

func ParseZ(r io.Reader) (*Status, error)

type SubmoduleStatus ¶

type SubmoduleStatus struct {
	IsSubmodule      bool // true if this entry represents a submodule
	CommitChanged    bool // true if submodule commit has changed
	HasModifications bool // true if submodule has tracked changes
	HasUntracked     bool // true if submodule has untracked changes
}

SubmoduleStatus represents submodule state information.

For regular files, IsSubmodule is false and other fields are ignored. For submodules, the flags indicate different types of changes:

• CommitChanged: submodule commit differs from what's recorded
• HasModifications: tracked files within submodule have changes
• HasUntracked: untracked changes exist within submodule

func (s SubmoduleStatus) String() string

"N..." when the entry is not a submodule
"S<c><m><u>" when the entry is a submodule
<c> is "C" if the commit changed; otherwise "."
<m> is "M" if it has tracked changes; otherwise "."
<u> is "U" if there are untracked changes; otherwise "."

type UnmergedEntry ¶

type UnmergedEntry struct {
	XY    XYFlag          // conflict type XY values
	Sub   SubmoduleStatus // submodule state information
	Mode1 FileMode        // file mode in stage 1 (common base)
	Mode2 FileMode        // file mode in stage 2 (ours)
	Mode3 FileMode        // file mode in stage 3 (theirs)
	ModeW FileMode        // file mode in worktree
	Hash1 string          // object hash in stage 1 (common base)
	Hash2 string          // object hash in stage 2 (ours)
	Hash3 string          // object hash in stage 3 (theirs)
	Path  string          // file path relative to repository root
}

UnmergedEntry represents a file with merge conflicts.

Corresponds to porcelain=v2 status lines starting with "u". Contains information about all three merge stages: base (1), ours (2), and theirs (3).

func (UnmergedEntry) Type() EntryType

type UntrackedEntry ¶

type UntrackedEntry struct {
	Path string // file path relative to repository root
}

UntrackedEntry represents an untracked file.

Corresponds to git status lines starting with "?".

func (UntrackedEntry) Type() EntryType

type XYFlag ¶

type XYFlag struct {
	X State // index status
	Y State // working tree status
}

XYFlag holds the two-character XY status codes (index + worktree). X represents staged changes, Y represents unstaged changes. Unchanged files use "." in porcelain=v2, not space.

func (xy XYFlag) MarshalText() ([]byte, error)

func (xy XYFlag) String() string

func (xy *XYFlag) UnmarshalText(text []byte) error