git_commands

package
v0.32.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 17, 2022 License: MIT Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const CurrentBranchNameRegex = `(?m)^\*.*?([^ ]*?)\)?$`

this takes something like:

  • (HEAD detached at 264fc6f5) remotes

and returns '264fc6f5' as the second match

Variables

This section is empty.

Functions

This section is empty.

Types

type BranchCommands 

type BranchCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewBranchCommands 

func NewBranchCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
) *BranchCommands

func (*BranchCommands) AllBranchesLogCmdObj 

func (self *BranchCommands) AllBranchesLogCmdObj() oscommands.ICmdObj

func (*BranchCommands) Checkout 

func (self *BranchCommands) Checkout(branch string, options CheckoutOptions) error

func (*BranchCommands) CurrentBranchName 

func (self *BranchCommands) CurrentBranchName() (string, string, error)

CurrentBranchName get the current branch name and displayname. the first returned string is the name and the second is the displayname e.g. name is 123asdf and displayname is '(HEAD detached at 123asdf)'

func (*BranchCommands) Delete 

func (self *BranchCommands) Delete(branch string, force bool) error

Delete delete branch

func (*BranchCommands) GetCommitDifferences 

func (self *BranchCommands) GetCommitDifferences(from, to string) (string, string)

GetCommitDifferences checks how many pushables/pullables there are for the current branch

func (*BranchCommands) GetCurrentBranchUpstreamDifferenceCount 

func (self *BranchCommands) GetCurrentBranchUpstreamDifferenceCount() (string, string)

func (*BranchCommands) GetGraph 

func (self *BranchCommands) GetGraph(branchName string) (string, error)

GetGraph gets the color-formatted graph of the log for the given branch Currently it limits the result to 100 commits, but when we get async stuff working we can do lazy loading

func (*BranchCommands) GetGraphCmdObj 

func (self *BranchCommands) GetGraphCmdObj(branchName string) oscommands.ICmdObj

func (*BranchCommands) GetRawBranches 

func (self *BranchCommands) GetRawBranches() (string, error)

func (*BranchCommands) GetUpstreamDifferenceCount 

func (self *BranchCommands) GetUpstreamDifferenceCount(branchName string) (string, string)

func (*BranchCommands) IsHeadDetached 

func (self *BranchCommands) IsHeadDetached() bool

func (*BranchCommands) Merge 

func (self *BranchCommands) Merge(branchName string, opts MergeOpts) error

func (*BranchCommands) New 

func (self *BranchCommands) New(name string, base string) error

New creates a new branch

func (*BranchCommands) Rename 

func (self *BranchCommands) Rename(oldName string, newName string) error

func (*BranchCommands) SetCurrentBranchUpstream 

func (self *BranchCommands) SetCurrentBranchUpstream(remoteName string, remoteBranchName string) error

func (*BranchCommands) SetUpstream 

func (self *BranchCommands) SetUpstream(remoteName string, remoteBranchName string, branchName string) error

type CheckoutOptions 

type CheckoutOptions struct {
	Force   bool
	EnvVars []string
}

Checkout checks out a branch (or commit), with --force if you set the force arg to true

type CommitCommands 

type CommitCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewCommitCommands 

func NewCommitCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
) *CommitCommands

func (*CommitCommands) AmendHead 

func (self *CommitCommands) AmendHead() error

AmendHead amends HEAD with whatever is staged in your working tree

func (*CommitCommands) AmendHeadCmdObj 

func (self *CommitCommands) AmendHeadCmdObj() oscommands.ICmdObj

func (*CommitCommands) CommitCmdObj 

func (self *CommitCommands) CommitCmdObj(message string) oscommands.ICmdObj

func (*CommitCommands) CommitEditorCmdObj 

func (self *CommitCommands) CommitEditorCmdObj() oscommands.ICmdObj

runs git commit without the -m argument meaning it will invoke the user's editor

func (*CommitCommands) CreateFixupCommit 

func (self *CommitCommands) CreateFixupCommit(sha string) error

CreateFixupCommit creates a commit that fixes up a previous commit

func (*CommitCommands) GetCommitMessage 

func (self *CommitCommands) GetCommitMessage(commitSha string) (string, error)

func (*CommitCommands) GetCommitMessageFirstLine 

func (self *CommitCommands) GetCommitMessageFirstLine(sha string) (string, error)

func (*CommitCommands) GetHeadCommitMessage 

func (self *CommitCommands) GetHeadCommitMessage() (string, error)

Get the subject of the HEAD commit

func (*CommitCommands) ResetToCommit 

func (self *CommitCommands) ResetToCommit(sha string, strength string, envVars []string) error

ResetToCommit reset to commit

func (*CommitCommands) Revert 

func (self *CommitCommands) Revert(sha string) error

Revert reverts the selected commit by sha

func (*CommitCommands) RevertMerge 

func (self *CommitCommands) RevertMerge(sha string, parentNumber int) error

func (*CommitCommands) RewordLastCommit 

func (self *CommitCommands) RewordLastCommit(message string) error

RewordLastCommit rewords the topmost commit with the given message

func (*CommitCommands) ShowCmdObj 

func (self *CommitCommands) ShowCmdObj(sha string, filterPath string) oscommands.ICmdObj

type ConfigCommands 

type ConfigCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewConfigCommands 

func NewConfigCommands(
	common *common.Common,
	gitConfig git_config.IGitConfig,
	repo *gogit.Repository,
) *ConfigCommands

func (*ConfigCommands) Branches 

func (self *ConfigCommands) Branches() (map[string]*config.Branch, error)

returns the repo's branches as specified in the git config

func (*ConfigCommands) ConfiguredPager 

func (self *ConfigCommands) ConfiguredPager() string

func (*ConfigCommands) GetCoreEditor 

func (self *ConfigCommands) GetCoreEditor() string

func (*ConfigCommands) GetGitFlowPrefixes 

func (self *ConfigCommands) GetGitFlowPrefixes() string

func (*ConfigCommands) GetPager 

func (self *ConfigCommands) GetPager(width int) string

func (*ConfigCommands) GetPushToCurrent 

func (self *ConfigCommands) GetPushToCurrent() bool

this determines whether the user has configured to push to the remote branch of the same name as the current or not

func (*ConfigCommands) GetRemoteURL 

func (self *ConfigCommands) GetRemoteURL() string

GetRemoteURL returns current repo remote url

func (*ConfigCommands) GetShowUntrackedFiles 

func (self *ConfigCommands) GetShowUntrackedFiles() string

func (*ConfigCommands) UsingGpg 

func (self *ConfigCommands) UsingGpg() bool

UsingGpg tells us whether the user has gpg enabled so that we can know whether we need to run a subprocess to allow them to enter their password

type CustomCommands 

type CustomCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewCustomCommands 

func NewCustomCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
) *CustomCommands

func (*CustomCommands) RunWithOutput 

func (self *CustomCommands) RunWithOutput(cmdStr string) (string, error)

Only to be used for the sake of running custom commands specified by the user. If you want to run a new command, try finding a place for it in one of the neighbouring files, or creating a new BlahCommands struct to hold it.

type FetchOptions 

type FetchOptions struct {
	Background bool
	RemoteName string
	BranchName string
}

type FileCommands 

type FileCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewFileCommands 

func NewFileCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	config *ConfigCommands,
	osCommand FileOSCommand,
) *FileCommands

func (*FileCommands) Cat 

func (self *FileCommands) Cat(fileName string) (string, error)

Cat obtains the content of a file

func (*FileCommands) GetEditCmdStr 

func (self *FileCommands) GetEditCmdStr(filename string, lineNumber int) (string, error)

type FileOSCommand 

type FileOSCommand interface {
	Getenv(string) string
}

type FlowCommands 

type FlowCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewFlowCommands 

func NewFlowCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	config *ConfigCommands,
) *FlowCommands

func (*FlowCommands) FinishCmdObj 

func (self *FlowCommands) FinishCmdObj(branchName string) (oscommands.ICmdObj, error)

func (*FlowCommands) GitFlowEnabled 

func (self *FlowCommands) GitFlowEnabled() bool

func (*FlowCommands) StartCmdObj 

func (self *FlowCommands) StartCmdObj(branchType string, name string) oscommands.ICmdObj

type MergeOpts 

type MergeOpts struct {
	FastForwardOnly bool
}

type PatchCommands 

type PatchCommands struct {
	*common.Common

	PatchManager *patch.PatchManager
	// contains filtered or unexported fields
}

func NewPatchCommands 

func NewPatchCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	rebaseCommands *RebaseCommands,
	commitCommands *CommitCommands,
	configCommands *ConfigCommands,
	statusCommands *StatusCommands,
	patchManager *patch.PatchManager,
) *PatchCommands

func (*PatchCommands) DeletePatchesFromCommit 

func (self *PatchCommands) DeletePatchesFromCommit(commits []*models.Commit, commitIndex int) error

DeletePatchesFromCommit applies a patch in reverse for a commit

func (*PatchCommands) MovePatchIntoIndex 

func (self *PatchCommands) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, stash bool) error

func (*PatchCommands) MovePatchToSelectedCommit 

func (self *PatchCommands) MovePatchToSelectedCommit(commits []*models.Commit, sourceCommitIdx int, destinationCommitIdx int) error

func (*PatchCommands) PullPatchIntoNewCommit 

func (self *PatchCommands) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx int) error

type PullOptions 

type PullOptions struct {
	RemoteName      string
	BranchName      string
	FastForwardOnly bool
}

type PushOpts 

type PushOpts struct {
	Force          bool
	UpstreamRemote string
	UpstreamBranch string
	SetUpstream    bool
}

Push pushes to a branch

type RebaseCommands 

type RebaseCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewRebaseCommands 

func NewRebaseCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	osCommand *oscommands.OSCommand,
	commitCommands *CommitCommands,
	workingTreeCommands *WorkingTreeCommands,
	configCommands *ConfigCommands,
	dotGitDir string,
) *RebaseCommands

func (*RebaseCommands) AbortRebase 

func (self *RebaseCommands) AbortRebase() error

func (*RebaseCommands) AmendTo 

func (self *RebaseCommands) AmendTo(sha string) error

AmendTo amends the given commit with whatever files are staged

func (*RebaseCommands) BeginInteractiveRebaseForCommit 

func (self *RebaseCommands) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error

BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current commit and pick all others. After this you'll want to call `self.ContinueRebase()

func (*RebaseCommands) CherryPickCommits 

func (self *RebaseCommands) CherryPickCommits(commits []*models.Commit) error

CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD

func (*RebaseCommands) ContinueRebase 

func (self *RebaseCommands) ContinueRebase() error

func (*RebaseCommands) DiscardOldFileChanges 

func (self *RebaseCommands) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error

DiscardOldFileChanges discards changes to a file from an old commit

func (*RebaseCommands) EditRebaseTodo 

func (self *RebaseCommands) EditRebaseTodo(index int, action string) error

EditRebaseTodo sets the action at a given index in the git-rebase-todo file

func (*RebaseCommands) GenerateGenericRebaseTodo 

func (self *RebaseCommands) GenerateGenericRebaseTodo(commits []*models.Commit, actionIndex int, action string) (string, string, error)

func (*RebaseCommands) GenericMergeOrRebaseAction 

func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, command string) error

GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue" By default we skip the editor in the case where a commit will be made

func (*RebaseCommands) GenericMergeOrRebaseActionCmdObj 

func (self *RebaseCommands) GenericMergeOrRebaseActionCmdObj(commandType string, command string) oscommands.ICmdObj

func (*RebaseCommands) InteractiveRebase 

func (self *RebaseCommands) InteractiveRebase(commits []*models.Commit, index int, action string) error

func (*RebaseCommands) MoveCommitDown 

func (self *RebaseCommands) MoveCommitDown(commits []*models.Commit, index int) error

func (*RebaseCommands) MoveTodoDown 

func (self *RebaseCommands) MoveTodoDown(index int) error

MoveTodoDown moves a rebase todo item down by one position

func (*RebaseCommands) PrepareInteractiveRebaseCommand 

func (self *RebaseCommands) PrepareInteractiveRebaseCommand(baseSha string, todo string, overrideEditor bool) oscommands.ICmdObj

PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase we tell git to run lazygit to edit the todo list, and we pass the client lazygit a todo string to write to the todo file

func (*RebaseCommands) RebaseBranch 

func (self *RebaseCommands) RebaseBranch(branchName string) error

RebaseBranch interactive rebases onto a branch

func (*RebaseCommands) RewordCommit 

func (self *RebaseCommands) RewordCommit(commits []*models.Commit, index int, message string) error

func (*RebaseCommands) RewordCommitInEditor 

func (self *RebaseCommands) RewordCommitInEditor(commits []*models.Commit, index int) (oscommands.ICmdObj, error)

func (*RebaseCommands) SquashAllAboveFixupCommits 

func (self *RebaseCommands) SquashAllAboveFixupCommits(sha string) error

SquashAllAboveFixupCommits squashes all fixup! commits above the given one

type RemoteCommands 

type RemoteCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewRemoteCommands 

func NewRemoteCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
) *RemoteCommands

func (*RemoteCommands) AddRemote 

func (self *RemoteCommands) AddRemote(name string, url string) error

func (*RemoteCommands) CheckRemoteBranchExists 

func (self *RemoteCommands) CheckRemoteBranchExists(branchName string) bool

CheckRemoteBranchExists Returns remote branch

func (*RemoteCommands) DeleteRemoteBranch 

func (self *RemoteCommands) DeleteRemoteBranch(remoteName string, branchName string) error

func (*RemoteCommands) RemoveRemote 

func (self *RemoteCommands) RemoveRemote(name string) error

func (*RemoteCommands) RenameRemote 

func (self *RemoteCommands) RenameRemote(oldRemoteName string, newRemoteName string) error

func (*RemoteCommands) UpdateRemoteUrl 

func (self *RemoteCommands) UpdateRemoteUrl(remoteName string, updatedUrl string) error

type StashCommands 

type StashCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewStashCommands 

func NewStashCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	osCommand *oscommands.OSCommand,
	fileLoader *loaders.FileLoader,
	workingTree *WorkingTreeCommands,
) *StashCommands

func (*StashCommands) Apply 

func (self *StashCommands) Apply(index int) error

func (*StashCommands) Drop 

func (self *StashCommands) Drop(index int) error

func (*StashCommands) Pop 

func (self *StashCommands) Pop(index int) error

func (*StashCommands) Save 

func (self *StashCommands) Save(message string) error

Save save stash TODO: before calling this, check if there is anything to save

func (*StashCommands) SaveStagedChanges 

func (self *StashCommands) SaveStagedChanges(message string) error

SaveStagedChanges stashes only the currently staged changes. This takes a few steps shoutouts to Joe on https://stackoverflow.com/questions/14759748/stashing-only-staged-changes-in-git-is-it-possible

func (*StashCommands) ShowStashEntryCmdObj 

func (self *StashCommands) ShowStashEntryCmdObj(index int) oscommands.ICmdObj

type StatusCommands 

type StatusCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewStatusCommands 

func NewStatusCommands(
	common *common.Common,
	osCommand *oscommands.OSCommand,
	repo *gogit.Repository,
	dotGitDir string,
) *StatusCommands

func (*StatusCommands) IsBareRepo 

func (self *StatusCommands) IsBareRepo() bool

func (*StatusCommands) IsInMergeState 

func (self *StatusCommands) IsInMergeState() (bool, error)

IsInMergeState states whether we are still mid-merge

func (*StatusCommands) RebaseMode 

func (self *StatusCommands) RebaseMode() (enums.RebaseMode, error)

RebaseMode returns "" for non-rebase mode, "normal" for normal rebase and "interactive" for interactive rebase

func (*StatusCommands) WorkingTreeState 

func (self *StatusCommands) WorkingTreeState() enums.RebaseMode

type SubmoduleCommands 

type SubmoduleCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewSubmoduleCommands 

func NewSubmoduleCommands(common *common.Common, cmd oscommands.ICmdObjBuilder, dotGitDir string) *SubmoduleCommands

func (*SubmoduleCommands) Add 

func (self *SubmoduleCommands) Add(name string, path string, url string) error

func (*SubmoduleCommands) BulkDeinitCmdObj 

func (self *SubmoduleCommands) BulkDeinitCmdObj() oscommands.ICmdObj

func (*SubmoduleCommands) BulkInitCmdObj 

func (self *SubmoduleCommands) BulkInitCmdObj() oscommands.ICmdObj

func (*SubmoduleCommands) BulkUpdateCmdObj 

func (self *SubmoduleCommands) BulkUpdateCmdObj() oscommands.ICmdObj

func (*SubmoduleCommands) Delete 

func (self *SubmoduleCommands) Delete(submodule *models.SubmoduleConfig) error

func (*SubmoduleCommands) ForceBulkUpdateCmdObj 

func (self *SubmoduleCommands) ForceBulkUpdateCmdObj() oscommands.ICmdObj

func (*SubmoduleCommands) GetConfigs 

func (self *SubmoduleCommands) GetConfigs() ([]*models.SubmoduleConfig, error)

func (*SubmoduleCommands) Init 

func (self *SubmoduleCommands) Init(path string) error

func (*SubmoduleCommands) Reset 

func (self *SubmoduleCommands) Reset(submodule *models.SubmoduleConfig) error

func (*SubmoduleCommands) ResetSubmodules 

func (self *SubmoduleCommands) ResetSubmodules(submodules []*models.SubmoduleConfig) error

func (*SubmoduleCommands) Stash 

func (self *SubmoduleCommands) Stash(submodule *models.SubmoduleConfig) error

func (*SubmoduleCommands) Update 

func (self *SubmoduleCommands) Update(path string) error

func (*SubmoduleCommands) UpdateAll 

func (self *SubmoduleCommands) UpdateAll() error

func (*SubmoduleCommands) UpdateUrl 

func (self *SubmoduleCommands) UpdateUrl(name string, path string, newUrl string) error

type SyncCommands 

type SyncCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewSyncCommands 

func NewSyncCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
) *SyncCommands

func (*SyncCommands) FastForward 

func (self *SyncCommands) FastForward(branchName string, remoteName string, remoteBranchName string) error

func (*SyncCommands) Fetch 

func (self *SyncCommands) Fetch(opts FetchOptions) error

Fetch fetch git repo

func (*SyncCommands) FetchRemote 

func (self *SyncCommands) FetchRemote(remoteName string) error

func (*SyncCommands) Pull 

func (self *SyncCommands) Pull(opts PullOptions) error

func (*SyncCommands) Push 

func (self *SyncCommands) Push(opts PushOpts) error

func (*SyncCommands) PushCmdObj 

func (self *SyncCommands) PushCmdObj(opts PushOpts) (oscommands.ICmdObj, error)

type TagCommands 

type TagCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewTagCommands 

func NewTagCommands(common *common.Common, cmd oscommands.ICmdObjBuilder) *TagCommands

func (*TagCommands) CreateAnnotated 

func (self *TagCommands) CreateAnnotated(tagName, commitSha, msg string) error

func (*TagCommands) CreateLightweight 

func (self *TagCommands) CreateLightweight(tagName string, commitSha string) error

func (*TagCommands) Delete 

func (self *TagCommands) Delete(tagName string) error

func (*TagCommands) Push 

func (self *TagCommands) Push(remoteName string, tagName string) error

type WorkingTreeCommands 

type WorkingTreeCommands struct {
	*common.Common
	// contains filtered or unexported fields
}

func NewWorkingTreeCommands 

func NewWorkingTreeCommands(
	common *common.Common,
	cmd oscommands.ICmdObjBuilder,
	submoduleCommands *SubmoduleCommands,
	osCommand WorkingTreeOSCommand,
	fileLoader *loaders.FileLoader,
) *WorkingTreeCommands

func (*WorkingTreeCommands) ApplyPatch 

func (self *WorkingTreeCommands) ApplyPatch(patch string, flags ...string) error

func (*WorkingTreeCommands) BeforeAndAfterFileForRename 

func (self *WorkingTreeCommands) BeforeAndAfterFileForRename(file *models.File) (*models.File, *models.File, error)

func (*WorkingTreeCommands) CheckoutFile 

func (self *WorkingTreeCommands) CheckoutFile(commitSha, fileName string) error

CheckoutFile checks out the file for the given commit

func (*WorkingTreeCommands) DiscardAllDirChanges 

func (self *WorkingTreeCommands) DiscardAllDirChanges(node *filetree.FileNode) error

func (*WorkingTreeCommands) DiscardAllFileChanges 

func (self *WorkingTreeCommands) DiscardAllFileChanges(file *models.File) error

DiscardAllFileChanges directly

func (*WorkingTreeCommands) DiscardAnyUnstagedFileChanges 

func (self *WorkingTreeCommands) DiscardAnyUnstagedFileChanges() error

DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`

func (*WorkingTreeCommands) DiscardUnstagedDirChanges 

func (self *WorkingTreeCommands) DiscardUnstagedDirChanges(node *filetree.FileNode) error

func (*WorkingTreeCommands) DiscardUnstagedFileChanges 

func (self *WorkingTreeCommands) DiscardUnstagedFileChanges(file *models.File) error

DiscardUnstagedFileChanges directly

func (*WorkingTreeCommands) Ignore 

func (self *WorkingTreeCommands) Ignore(filename string) error

Ignore adds a file to the gitignore for the repo

func (*WorkingTreeCommands) OpenMergeTool 

func (self *WorkingTreeCommands) OpenMergeTool() error

func (*WorkingTreeCommands) OpenMergeToolCmdObj 

func (self *WorkingTreeCommands) OpenMergeToolCmdObj() oscommands.ICmdObj

func (*WorkingTreeCommands) RemoveTrackedFiles 

func (self *WorkingTreeCommands) RemoveTrackedFiles(name string) error

RemoveTrackedFiles will delete the given file(s) even if they are currently tracked

func (*WorkingTreeCommands) RemoveUntrackedDirFiles 

func (self *WorkingTreeCommands) RemoveUntrackedDirFiles(node *filetree.FileNode) error

func (*WorkingTreeCommands) RemoveUntrackedFiles 

func (self *WorkingTreeCommands) RemoveUntrackedFiles() error

RemoveUntrackedFiles runs `git clean -fd`

func (*WorkingTreeCommands) ResetAndClean 

func (self *WorkingTreeCommands) ResetAndClean() error

ResetAndClean removes all unstaged changes and removes all untracked files

func (*WorkingTreeCommands) ResetHard 

func (self *WorkingTreeCommands) ResetHard(ref string) error

ResetHardHead runs `git reset --hard`

func (*WorkingTreeCommands) ResetMixed 

func (self *WorkingTreeCommands) ResetMixed(ref string) error

func (*WorkingTreeCommands) ResetSoft 

func (self *WorkingTreeCommands) ResetSoft(ref string) error

ResetSoft runs `git reset --soft HEAD`

func (*WorkingTreeCommands) ShowFileDiff 

func (self *WorkingTreeCommands) ShowFileDiff(from string, to string, reverse bool, fileName string, plain bool) (string, error)

ShowFileDiff get the diff of specified from and to. Typically this will be used for a single commit so it'll be 123abc^..123abc but when we're in diff mode it could be any 'from' to any 'to'. The reverse flag is also here thanks to diff mode.

func (*WorkingTreeCommands) ShowFileDiffCmdObj 

func (self *WorkingTreeCommands) ShowFileDiffCmdObj(from string, to string, reverse bool, fileName string, plain bool) oscommands.ICmdObj

func (*WorkingTreeCommands) StageAll 

func (self *WorkingTreeCommands) StageAll() error

StageAll stages all files

func (*WorkingTreeCommands) StageFile 

func (self *WorkingTreeCommands) StageFile(fileName string) error

StageFile stages a file

func (*WorkingTreeCommands) UnStageFile 

func (self *WorkingTreeCommands) UnStageFile(fileNames []string, reset bool) error

UnStageFile unstages a file we accept an array of filenames for the cases where a file has been renamed i.e. we accept the current name and the previous name

func (*WorkingTreeCommands) UnstageAll 

func (self *WorkingTreeCommands) UnstageAll() error

UnstageAll unstages all files

func (*WorkingTreeCommands) WorktreeFileDiff 

func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string

WorktreeFileDiff returns the diff of a file

func (*WorkingTreeCommands) WorktreeFileDiffCmdObj 

func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) oscommands.ICmdObj

type WorkingTreeOSCommand 

type WorkingTreeOSCommand interface {
	RemoveFile(string) error
	CreateFileWithContent(string, string) error
	AppendLineToFile(string, string) error
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.