status.go

package git

/*
#include <git2.h>
*/
import"C"

import (
"errors"
"runtime"
"unsafe"
)

typeStatusint

const (
StatusCurrentStatus=C.GIT_STATUS_CURRENT
StatusIndexNewStatus=C.GIT_STATUS_INDEX_NEW
StatusIndexModifiedStatus=C.GIT_STATUS_INDEX_MODIFIED
StatusIndexDeletedStatus=C.GIT_STATUS_INDEX_DELETED
StatusIndexRenamedStatus=C.GIT_STATUS_INDEX_RENAMED
StatusIndexTypeChangeStatus=C.GIT_STATUS_INDEX_TYPECHANGE
StatusWtNewStatus=C.GIT_STATUS_WT_NEW
StatusWtModifiedStatus=C.GIT_STATUS_WT_MODIFIED
StatusWtDeletedStatus=C.GIT_STATUS_WT_DELETED
StatusWtTypeChangeStatus=C.GIT_STATUS_WT_TYPECHANGE
StatusWtRenamedStatus=C.GIT_STATUS_WT_RENAMED
StatusIgnoredStatus=C.GIT_STATUS_IGNORED
StatusConflictedStatus=C.GIT_STATUS_CONFLICTED
)

typeStatusEntrystruct {
StatusStatus
HeadToIndexDiffDelta
IndexToWorkdirDiffDelta
}

funcstatusEntryFromC(statusEntry*C.git_status_entry) StatusEntry {
varheadToIndexDiffDelta=DiffDelta{}
varindexToWorkdirDiffDelta=DiffDelta{}

// Based on the libgit2 status example, head_to_index can be null in some cases
ifstatusEntry.head_to_index!=nil {
headToIndex=diffDeltaFromC(statusEntry.head_to_index)
 }
ifstatusEntry.index_to_workdir!=nil {
indexToWorkdir=diffDeltaFromC(statusEntry.index_to_workdir)
 }

returnStatusEntry{
Status: Status(statusEntry.status),
HeadToIndex: headToIndex,
IndexToWorkdir: indexToWorkdir,
 }
}

typeStatusListstruct {
doNotCompare
ptr*C.git_status_list
r*Repository
}

funcnewStatusListFromC(ptr*C.git_status_list, r*Repository) *StatusList {
ifptr==nil {
returnnil
 }

statusList:=&StatusList{
ptr: ptr,
r: r,
 }

runtime.SetFinalizer(statusList, (*StatusList).Free)
returnstatusList
}

func (statusList*StatusList) Free() {
ifstatusList.ptr==nil {
return
 }
runtime.SetFinalizer(statusList, nil)
C.git_status_list_free(statusList.ptr)
statusList.ptr=nil
}

func (statusList*StatusList) ByIndex(indexint) (StatusEntry, error) {
ifstatusList.ptr==nil {
returnStatusEntry{}, ErrInvalid
 }
ptr:=C.git_status_byindex(statusList.ptr, C.size_t(index))
ifptr==nil {
returnStatusEntry{}, errors.New("index out of Bounds")
 }
entry:=statusEntryFromC(ptr)
runtime.KeepAlive(statusList)

returnentry, nil
}

func (statusList*StatusList) EntryCount() (int, error) {
ifstatusList.ptr==nil {
return-1, ErrInvalid
 }
ret:=int(C.git_status_list_entrycount(statusList.ptr))
runtime.KeepAlive(statusList)

returnret, nil
}

typeStatusOptint

const (
StatusOptIncludeUntrackedStatusOpt=C.GIT_STATUS_OPT_INCLUDE_UNTRACKED
StatusOptIncludeIgnoredStatusOpt=C.GIT_STATUS_OPT_INCLUDE_IGNORED
StatusOptIncludeUnmodifiedStatusOpt=C.GIT_STATUS_OPT_INCLUDE_UNMODIFIED
StatusOptExcludeSubmodulesStatusOpt=C.GIT_STATUS_OPT_EXCLUDE_SUBMODULES
StatusOptRecurseUntrackedDirsStatusOpt=C.GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS
StatusOptDisablePathspecMatchStatusOpt=C.GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH
StatusOptRecurseIgnoredDirsStatusOpt=C.GIT_STATUS_OPT_RECURSE_IGNORED_DIRS
StatusOptRenamesHeadToIndexStatusOpt=C.GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX
StatusOptRenamesIndexToWorkdirStatusOpt=C.GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR
StatusOptSortCaseSensitivelyStatusOpt=C.GIT_STATUS_OPT_SORT_CASE_SENSITIVELY
StatusOptSortCaseInsensitivelyStatusOpt=C.GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY
StatusOptRenamesFromRewritesStatusOpt=C.GIT_STATUS_OPT_RENAMES_FROM_REWRITES
StatusOptNoRefreshStatusOpt=C.GIT_STATUS_OPT_NO_REFRESH
StatusOptUpdateIndexStatusOpt=C.GIT_STATUS_OPT_UPDATE_INDEX
)

typeStatusShowint

const (
StatusShowIndexAndWorkdirStatusShow=C.GIT_STATUS_SHOW_INDEX_AND_WORKDIR
StatusShowIndexOnlyStatusShow=C.GIT_STATUS_SHOW_INDEX_ONLY
StatusShowWorkdirOnlyStatusShow=C.GIT_STATUS_SHOW_WORKDIR_ONLY
)

typeStatusOptionsstruct {
ShowStatusShow
FlagsStatusOpt
Pathspec []string
}

func (v*Repository) StatusList(opts*StatusOptions) (*StatusList, error) {
varptr*C.git_status_list
varcopts*C.git_status_options

ifopts!=nil {
cpathspec:= C.git_strarray{}
ifopts.Pathspec!=nil {
cpathspec.count=C.size_t(len(opts.Pathspec))
cpathspec.strings=makeCStringsFromStrings(opts.Pathspec)
deferfreeStrarray(&cpathspec)
 }

copts=&C.git_status_options{
version: C.GIT_STATUS_OPTIONS_VERSION,
show: C.git_status_show_t(opts.Show),
flags: C.uint(opts.Flags),
pathspec: cpathspec,
 }
 } else {
copts=&C.git_status_options{}
ret:=C.git_status_options_init(copts, C.GIT_STATUS_OPTIONS_VERSION)
ifret<0 {
returnnil, MakeGitError(ret)
 }
 }

runtime.LockOSThread()
deferruntime.UnlockOSThread()

ret:=C.git_status_list_new(&ptr, v.ptr, copts)
ifret<0 {
returnnil, MakeGitError(ret)
 }

returnnewStatusListFromC(ptr, v), nil
}

func (v*Repository) StatusFile(pathstring) (Status, error) {
varstatusFlags C.uint
cPath:=C.CString(path)
deferC.free(unsafe.Pointer(cPath))

runtime.LockOSThread()
deferruntime.UnlockOSThread()

ret:=C.git_status_file(&statusFlags, v.ptr, cPath)
runtime.KeepAlive(v)
ifret<0 {
return0, MakeGitError(ret)
 }
returnStatus(statusFlags), nil
}