eric: comparison src/eric7/Plugins/VcsPlugins/vcsGit/git.py

-:2f70ca07f0af
+:4cd7e5a8b3cf
 def __init__(self, plugin, parent=None, name=None):
 """
 Constructor
 @param plugin reference to the plugin object
-@param parent parent widget (QWidget)
+@type VcsGitPlugin
-@param name name of this object (string)
+@param parent parent widget
+@type QWidget
+@param name name of this object
+@type str
 """
 VersionControl.__init__(self, parent, name)
 self.defaultOptions = {
 "global": [""],
 "commit": [""],
 def getPlugin(self):
 """
 Public method to get a reference to the plugin object.
-@return reference to the plugin object (VcsGitPlugin)
+@return reference to the plugin object
+@rtype VcsGitPlugin
 """
 return self.__plugin
 def vcsShutdown(self):
 """
 def initCommand(self, command):
 """
 Public method to initialize a command arguments list.
-@param command command name (string)
+@param command command name
-@return list of command options (list of string)
+@type str
+@return list of command options
+@rtype list of str
 """
 args = [command]
 return args
 def vcsExists(self):
 """
 Public method used to test for the presence of the git executable.
-@return flag indicating the existance (boolean) and an error message
+@return flag indicating the existance and an error message
-(string)
+@rtype tuple of (bool, str)
 """
 self.versionStr = ""
 errMsg = ""
 ioEncoding = Preferences.getSystem("IOEncoding")
 The initialization is done, when a project is converted into a
 Git controlled project. Therefore we always return TRUE without
 doing anything.
-@param vcsDir name of the VCS directory (string)
+@param vcsDir name of the VCS directory
-@param noDialog flag indicating quiet operations (boolean)
+@type str
-@return always TRUE
+@param noDialog flag indicating quiet operations
+@type bool
+@return always True
+@rtype bool
 """
 return True
 def vcsConvertProject(self, vcsDataDict, project, addAll=True):
 """
 """
 Public method used to import the project into the Git repository.
 @param vcsDataDict dictionary of data required for the import
 @type dict
-@param projectDir project directory (string)
+@param projectDir project directory
 @type str
 @param noDialog flag indicating quiet operations
 @type bool
 @param addAll flag indicating to add all files to the repository
 @type bool
 """
 Public method used to check the project out of a Git repository
 (clone).
 @param vcsDataDict dictionary of data required for the checkout
-@param projectDir project directory to create (string)
+@type dict
+@param projectDir project directory to create
+@type str
 @param noDialog flag indicating quiet operations
-@return flag indicating an execution without errors (boolean)
+@type bool
+@return flag indicating an execution without errors
+@rtype bool
 """
 noDialog = False
 vcsUrl = self.gitNormalizeURL(vcsDataDict["url"])
 args = self.initCommand("clone")
 def vcsExport(self, vcsDataDict, projectDir):
 """
 Public method used to export a directory from the Git repository.
 @param vcsDataDict dictionary of data required for the checkout
-@param projectDir project directory to create (string)
+@type dict
-@return flag indicating an execution without errors (boolean)
+@param projectDir project directory to create
+@type str
+@return flag indicating an execution without errors
+@rtype bool
 """
 status = self.vcsCheckout(vcsDataDict, projectDir)
 adminPath = os.path.join(projectDir, self.adminDirOrFile)
 if os.path.isdir(adminPath):
 shutil.rmtree(adminPath, ignore_errors=True)
 def vcsCommit(self, name, message="", noDialog=False, commitAll=True, amend=False):
 """
 Public method used to make the change of a file/directory permanent
 in the Git repository.
-@param name file/directory name to be committed (string or list of
+@param name file/directory name to be committed
-strings)
+@type str or list of str
-@param message message for this operation (string)
+@param message message for this operation
-@param noDialog flag indicating quiet operations (boolean)
+@type str
-@param commitAll flag indicating to commit all local changes (boolean)
+@param noDialog flag indicating quiet operations
-@param amend flag indicating to amend the HEAD commit (boolean)
+@type bool
+@param commitAll flag indicating to commit all local changes
+@type bool
+@param amend flag indicating to amend the HEAD commit
+@type bool
 """
 from .GitCommitDialog import GitCommitDialog
 if not noDialog:
 # call CommitDialog and get message from there
 def vcsUpdate(self, name, noDialog=False, revision=None):
 """
 Public method used to update a file/directory with the Git
 repository.
-@param name file/directory name to be updated (string or list of
+@param name file/directory name to be updated
-strings)
+@type str or list of str
-@param noDialog flag indicating quiet operations (boolean)
+@param noDialog flag indicating quiet operations
-@param revision revision to update to (string)
+@type bool
-@return flag indicating, that the update contained an add
+@param revision revision to update to
-or delete (boolean)
+@type str
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 args = self.initCommand("checkout")
 if revision:
 res = EricMessageBox.yesNo(
 None,
 def vcsAdd(self, name, isDir=False, noDialog=False):
 """
 Public method used to add a file/directory to the Git repository.
-@param name file/directory name to be added (string)
+@param name file/directory name to be added
-@param isDir flag indicating name is a directory (boolean)
+@type str
+@param isDir flag indicating name is a directory
+@type bool
 @param noDialog flag indicating quiet operations
+@type bool
 """
 args = self.initCommand("add")
 args.append("-v")
 if isinstance(name, list):
 def vcsAddBinary(self, name, isDir=False):
 """
 Public method used to add a file/directory in binary mode to the
 Git repository.
-@param name file/directory name to be added (string)
+@param name file/directory name to be added
-@param isDir flag indicating name is a directory (boolean)
+@type str
+@param isDir flag indicating name is a directory
+@type bool
 """
 self.vcsAdd(name, isDir)
 def vcsAddTree(self, path):
 """
 Public method to add a directory tree rooted at path to the Git
 repository.
-@param path root directory of the tree to be added (string or list of
+@param path root directory of the tree to be added
-strings))
+@type str or list of str
 """
 self.vcsAdd(path, isDir=False)
 def vcsRemove(
 self, name, project=False, noDialog=False, stageOnly=False  # noqa: U100
 Public method used to remove a file/directory from the Git
 repository.
 The default operation is to remove the local copy as well.
-@param name file/directory name to be removed (string or list of
+@param name file/directory name to be removed
-strings))
+@type str or list of str
-@param project flag indicating deletion of a project tree (boolean)
+@param project flag indicating deletion of a project tree
-(not needed)
+@type bool
-@param noDialog flag indicating quiet operations (boolean)
+@param noDialog flag indicating quiet operations
+@type bool
 @param stageOnly flag indicating to just remove the file from the
-staging area (boolean)
+staging area
-@return flag indicating successful operation (boolean)
+@type bool
+@return flag indicating successful operation
+@rtype bool
 """
 args = self.initCommand("rm")
 if noDialog and "--force" not in args:
 args.append("--force")
 if stageOnly:
 def vcsMove(self, name, project, target=None, noDialog=False):
 """
 Public method used to move a file/directory.
-@param name file/directory name to be moved (string)
+@param name file/directory name to be moved
+@type str
 @param project reference to the project object
-@param target new name of the file/directory (string)
+@type Project
+@param target new name of the file/directory
+@type str
 @param noDialog flag indicating quiet operations
-@return flag indicating successful operation (boolean)
+@type bool
+@return flag indicating successful operation
+@rtype bool
 """
 from .GitCopyDialog import GitCopyDialog
 isDir = os.path.isdir(name)
 def vcsLogBrowser(self, name, isFile=False):
 """
 Public method used to browse the log of a file/directory from the
 Git repository.
-@param name file/directory name to show the log of (string)
+@param name file/directory name to show the log of
+@type str
 @param isFile flag indicating log for a file is to be shown
-(boolean)
+@type bool
 """
 from .GitLogBrowserDialog import GitLogBrowserDialog
 if self.logBrowser is None:
 self.logBrowser = GitLogBrowserDialog(self)
 def gitReflogBrowser(self, projectDir):
 """
 Public method used to browse the reflog of the project.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitReflogBrowserDialog import GitReflogBrowserDialog
 if self.reflogBrowser is None:
 self.reflogBrowser = GitReflogBrowserDialog(self)
 If name is a directory and is the project directory, all project files
 are saved first. If name is a file (or list of files), which is/are
 being edited and has unsaved modification, they can be saved or the
 operation may be aborted.
-@param name file/directory name to be diffed (string)
+@param name file/directory name to be diffed
+@type str
 """
 from .GitDiffDialog import GitDiffDialog
 names = name[:] if isinstance(name, list) else [name]
 for nam in names:
 """
 Public method used to view the status of files/directories in the
 Git repository.
 @param name file/directory name(s) to show the status of
-(string or list of strings)
+@type str or list of str
 """
 from .GitStatusDialog import GitStatusDialog
 if self.status is None:
 self.status = GitStatusDialog(self)
 def gitUnstage(self, name):
 """
 Public method used to unstage a file/directory.
-@param name file/directory name to be reverted (string)
+@param name file/directory name to be reverted
-@return flag indicating, that the update contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 if isinstance(name, list):
 dname, fnames = self.splitPathList(name)
 else:
 dname, fname = self.splitPath(name)
 def vcsMerge(self, name):
 """
 Public method used to merge a URL/revision into the local project.
-@param name file/directory name to be merged (string)
+@param name file/directory name to be merged
+@type str
 """
 from .GitMergeDialog import GitMergeDialog
 dname, fname = self.splitPath(name)
 def vcsSwitch(self, name):
 """
 Public method used to switch a working directory to a different
 revision.
-@param name directory name to be switched (string)
+@param name directory name to be switched
-@return flag indicating, that the switch contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the switch contained an add or delete
+@rtype bool
 """
 from .GitRevisionSelectionDialog import GitRevisionSelectionDialog
 dname, fname = self.splitPath(name)
 def vcsRegisteredState(self, name):
 """
 Public method used to get the registered state of a file in the vcs.
-@param name filename to check (string)
+@param name filename to check
-@return a combination of canBeCommited and canBeAdded
+@type str
+@return registered state (one of canBeCommited and canBeAdded)
+@rtype int
 """
 if name.endswith(os.sep):
 name = name[:-1]
 name = os.path.normcase(name)
 dname, fname = self.splitPath(name)
 <b>Note:</b> If a shortcut is to be taken, the code will only check,
 if the named directory has been scanned already. If so, it is assumed,
 that the states for all files have been populated by the previous run.
 @param names dictionary with all filenames to be checked as keys
-@param dname directory to check in (string)
+@type dict
-@param shortcut flag indicating a shortcut should be taken (boolean)
+@param dname directory to check in
+@type str
+@param shortcut flag indicating a shortcut should be taken
+@type bool
 @return the received dictionary completed with a combination of
 canBeCommited and canBeAdded or None in order to signal an error
+@rtype dict
 """
 if dname.endswith(os.sep):
 dname = dname[:-1]
 dname = os.path.normcase(dname)
 def vcsName(self):
 """
 Public method returning the name of the vcs.
-@return always 'Git' (string)
+@return always 'Git'
+@rtype str
 """
 return "Git"
 def vcsInitConfig(self, project):
 """
 Public method to initialize the VCS configuration.
 This method ensures, that an ignore file exists.
-@param project reference to the project (Project)
+@param project reference to the project
+@type Project
 """
 ppath = project.getProjectPath()
 if ppath:
 ignoreName = os.path.join(ppath, Git.IgnoreFileName)
 if not os.path.exists(ignoreName):
 def vcsCleanup(self, name):
 """
 Public method used to cleanup the working directory.
-@param name directory name to be cleaned up (string)
+@param name directory name to be cleaned up
+@type str
 """
 patterns = self.__plugin.getPreferences("CleanupPatterns").split()
 entries = []
 for pat in patterns:
 def vcsCommandLine(self, name):
 """
 Public method used to execute arbitrary Git commands.
-@param name directory name of the working directory (string)
+@param name directory name of the working directory
+@type str
 """
 from .GitCommandDialog import GitCommandDialog
 dlg = GitCommandDialog(self.commandHistory, name)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 ):
 """
 Public method to get a dialog to enter repository info.
 @param project reference to the project object
-@param archive name of the project in the repository (string)
+@type Project
+@param archive name of the project in the repository
+@type str
 @param editable flag indicating that the project name is editable
-(boolean)
+@type bool
-@param parent parent widget (QWidget)
+@param parent parent widget
-@return reference to the instantiated options dialog (GitOptionsDialog)
+@type QWidget
+@return reference to the instantiated options dialog
+@rtype GitOptionsDialog
 """
 from .GitOptionsDialog import GitOptionsDialog
 return GitOptionsDialog(self, project, parent)
 def vcsNewProjectOptionsDialog(self, parent=None):
 """
 Public method to get a dialog to enter repository info for getting a
 new project.
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 @return reference to the instantiated options dialog
-(GitNewProjectOptionsDialog)
+@rtype GitNewProjectOptionsDialog
 """
 from .GitNewProjectOptionsDialog import GitNewProjectOptionsDialog
 return GitNewProjectOptionsDialog(self, parent)
 def vcsRepositoryInfos(self, ppath):
 """
 Public method to retrieve information about the repository.
-@param ppath local path to get the repository infos (string)
+@param ppath local path to get the repository infos
-@return string with ready formated info for display (string)
+@type str
+@return string with ready formated info for display
+@rtype str
 """
 formatTemplate = (
 "format:"
 "%h%n"
 "%p%n"
 def vcsSupportCommandOptions(self):
 """
 Public method to signal the support of user settable command options.
 @return flag indicating the support  of user settable command options
-(boolean)
+@rtype bool
 """
 return False
 ###########################################################################
 ## Git specific methods are below.
 def gitNormalizeURL(self, url):
 """
 Public method to normalize a url for Git.
-@param url url string (string)
+@param url url string
-@return properly normalized url for git (string)
+@type str
+@return properly normalized url for git
+@rtype str
 """
 url = url.replace("\\", "/")
 if url.endswith("/"):
 url = url[:-1]
 urll = url.split("//")
 def gitCreateIgnoreFile(self, name, autoAdd=False):
 """
 Public method to create the ignore file.
-@param name directory name to create the ignore file in (string)
+@param name directory name to create the ignore file in
-@param autoAdd flag indicating to add it automatically (boolean)
+@type str
+@param autoAdd flag indicating to add it automatically
+@type bool
 @return flag indicating success
+@rtype bool
 """
 status = False
 ignorePatterns = [
 ".eric6project/",
 ".eric7project/",
 def gitCopy(self, name, project):
 """
 Public method used to copy a file/directory.
-@param name file/directory name to be copied (string)
+@param name file/directory name to be copied
+@type str
 @param project reference to the project object
-@return flag indicating successful operation (boolean)
+@type Project
+@return flag indicating successful operation
+@rtype bool
 """
 from .GitCopyDialog import GitCopyDialog
 dlg = GitCopyDialog(name)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 being edited and has unsaved modification, they can be saved or the
 operation may be aborted.
 This method gives the chance to enter the revisions to be compared.
-@param name file/directory name to be diffed (string)
+@param name file/directory name to be diffed
+@type str
 """
 from .GitDiffDialog import GitDiffDialog
 from .GitRevisionsSelectionDialog import GitRevisionsSelectionDialog
 if isinstance(name, list):
 def __gitGetFileForRevision(self, name, rev=""):
 """
 Private method to get a file for a specific revision from the
 repository.
-@param name file name to get from the repository (string)
+@param name file name to get from the repository
-@param rev revision to retrieve (string)
+@type str
-@return contents of the file (string) and an error message (string)
+@param rev revision to retrieve
+@type str
+@return contents of the file (string) and an error message
+@rtype str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(self.splitPath(name)[0])
 if not repodir:
 return False
 def vcsSbsDiff(self, name, extended=False, revisions=None):
 """
 Public method used to view the difference of a file to the Git
 repository side-by-side.
-@param name file name to be diffed (string)
+@param name file name to be diffed
-@param extended flag indicating the extended variant (boolean)
+@type str
-@param revisions tuple of two revisions (tuple of strings)
+@param extended flag indicating the extended variant
+@type bool
+@param revisions tuple of two revisions
+@type tuple of (str, str)
 @exception ValueError raised to indicate an invalid name parameter
 """
 from eric7.UI.CompareDialog import CompareDialog
 from .GitRevisionsSelectionDialog import GitRevisionsSelectionDialog
 def gitFetch(self, name):
 """
 Public method to fetch changes from a remote repository.
-@param name directory name (string)
+@param name directory name
+@type str
 """
 from .GitFetchDialog import GitFetchDialog
 # find the root of the repo
 repodir = self.findRepoRoot(self.splitPath(name)[0])
 def gitPull(self, name):
 """
 Public method used to pull changes from a remote Git repository.
-@param name directory name of the project to be pulled to (string)
+@param name directory name of the project to be pulled to
-@return flag indicating, that the update contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 from .GitPullDialog import GitPullDialog
 # find the root of the repo
 repodir = self.findRepoRoot(self.splitPath(name)[0])
 def gitPush(self, name):
 """
 Public method used to push changes to a remote Git repository.
-@param name directory name of the project to be pushed from (string)
+@param name directory name of the project to be pushed from
+@type str
 """
 from .GitPushDialog import GitPushDialog
 # find the root of the repo
 repodir = self.findRepoRoot(self.splitPath(name)[0])
 def gitCommitMerge(self, name):
 """
 Public method to commit a failed merge.
-@param name file/directory name (string)
+@param name file/directory name
+@type str
 """
 dname, fname = self.splitPath(name)
 # find the root of the repo
 repodir = self.findRepoRoot(dname)
 def gitCancelMerge(self, name):
 """
 Public method to cancel an uncommitted or failed merge.
-@param name file/directory name (string)
+@param name file/directory name
-@return flag indicating, that the cancellation contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the cancellation contained an add or delete
+@rtype bool
 """
 dname, fname = self.splitPath(name)
 # find the root of the repo
 repodir = self.findRepoRoot(dname)
 def gitApply(self, repodir, patchFile, cached=False, reverse=False, noDialog=False):
 """
 Public method to apply a patch stored in a given file.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@param patchFile name of the patch file (string)
+@type str
+@param patchFile name of the patch file
+@type str
 @param cached flag indicating to apply the patch to the staging area
-(boolean)
+@type bool
-@param reverse flag indicating to apply the patch in reverse (boolean)
+@param reverse flag indicating to apply the patch in reverse
-@param noDialog flag indicating quiet operations (boolean)
+@type bool
+@param noDialog flag indicating quiet operations
+@type bool
 """
 args = self.initCommand("apply")
 if cached:
 args.append("--index")
 args.append("--cached")
 def gitApplyCheckPatches(self, projectDir, check=False):
 """
 Public method to apply a list of patch files or check, if they would
 apply cleanly.
-@param projectDir directory name of the project (string)
+@param projectDir directory name of the project
-@param check flag indicating to perform a check operation (boolean)
+@type str
+@param check flag indicating to perform a check operation
+@type bool
 """
 from .GitPatchFilesDialog import GitPatchFilesDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitShowPatchesStatistics(self, projectDir):
 """
 Public method to show statistics for a set of patch files.
-@param projectDir directory name of the project (string)
+@param projectDir directory name of the project
+@type str
 """
 from .GitPatchStatisticsDialog import GitPatchStatisticsDialog
 if self.patchStatisticsDialog is None:
 self.patchStatisticsDialog = GitPatchStatisticsDialog(self)
 def vcsTag(self, name, revision=None, tagName=None):
 """
 Public method used to set/remove a tag in the Git repository.
 @param name file/directory name to determine the repo root from
-(string)
+@type str
-@param revision revision to set tag for (string)
+@param revision revision to set tag for
-@param tagName name of the tag (string)
+@type str
-@return flag indicating a performed tag action (boolean)
+@param tagName name of the tag
+@type str
+@return flag indicating a performed tag action
+@rtype bool
 """
 from .GitTagDialog import GitTagDialog
 dname, fname = self.splitPath(name)
 def gitGetTagsList(self, repodir):
 """
 Public method to get the list of tags.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@return list of tags (list of string) or list of tuples of
+@type str
-tag name and flag indicating a local tag (list of tuple of string
+@return list of tags or list of tuples of tag name and flag indicating
-and boolean), if withType is True
+a local tag, if withType is True
+@rtype list of str or list of tuple of (str, bool)
 """
 args = self.initCommand("tag")
 args.append("--list")
 output = ""
 def gitListTagBranch(self, path, tags=True, listAll=True, merged=True):
 """
 Public method used to list the available tags or branches.
-@param path directory name of the project (string)
+@param path directory name of the project
+@type str
 @param tags flag indicating listing of branches or tags
 (False = branches, True = tags)
-@param listAll flag indicating to show all tags or branches (boolean)
+@type bool
-@param merged flag indicating to show only merged or non-merged
+@param listAll flag indicating to show all tags or branches
-branches (boolean)
+@type bool
+@param merged flag indicating to show only merged or non-merged branches
+@type bool
 """
 from .GitTagBranchListDialog import GitTagBranchListDialog
 if self.tagbranchList is None:
 self.tagbranchList = GitTagBranchListDialog(self)
 self, repodir, withMain=False, allBranches=False, remotes=False
 ):
 """
 Public method to get the list of branches.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@param withMain flag indicating to get 'main' as well (boolean)
+@type str
-@param allBranches flag indicating to return all branches (boolean)
+@param withMain flag indicating to get 'main' as well
-@param remotes flag indicating to return remote branches only (boolean)
+@type bool
-@return list of branches (list of string)
+@param allBranches flag indicating to return all branches
+@type bool
+@param remotes flag indicating to return remote branches only
+@type bool
+@return list of branches
+@rtype list of str
 """
 args = self.initCommand("branch")
 args.append("--list")
 if allBranches:
 args.append("--all")
 def gitGetCurrentBranch(self, repodir):
 """
 Public method used to show the current branch of the working directory.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@return name of the current branch (string)
+@type str
+@return name of the current branch
+@rtype str
 """
 args = self.initCommand("branch")
 args.append("--list")
 branchName = ""
 def gitBranch(self, name, revision=None, branchName=None, branchOp=None):
 """
 Public method used to create, delete or move a branch in the Git
 repository.
-@param name file/directory name to be branched (string)
+@param name file/directory name to be branched
-@param revision revision to set tag for (string)
+@type str
-@param branchName name of the branch (string)
+@param revision revision to set tag for
-@param branchOp desired branch operation (integer)
+@type str
-@return flag indicating a performed branch action (boolean) and
+@param branchName name of the branch
-a flag indicating, that the branch operation contained an add
+@type str
-or delete (boolean)
+@param branchOp desired branch operation
+@type int
+@return flag indicating a performed branch action and a flag indicating,
+that the branch operation contained an add or delete
+@rtype tuple of (bool, bool)
 """
 from .GitBranchDialog import GitBranchDialog
 dname, fname = self.splitPath(name)
 def gitDeleteRemoteBranch(self, name):
 """
 Public method to delete a branch from a remote repository.
-@param name file/directory name (string)
+@param name file/directory name
+@type str
 """
 from .GitBranchPushDialog import GitBranchPushDialog
 dname, fname = self.splitPath(name)
 def gitShowBranch(self, name):
 """
 Public method used to show the current branch of the working directory.
-@param name file/directory name (string)
+@param name file/directory name
+@type str
 """
 dname, fname = self.splitPath(name)
 # find the root of the repo
 repodir = self.findRepoRoot(dname)
 def gitBundle(self, projectDir):
 """
 Public method to create a bundle file.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitBundleDialog import GitBundleDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitVerifyBundle(self, projectDir):
 """
 Public method to verify a bundle file.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitBundleListHeads(self, projectDir):
 """
 Public method to list the heads contained in a bundle file.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitGetBundleHeads(self, repodir, bundleFile):
 """
 Public method to get a list of heads contained in a bundle file.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@param bundleFile file name of a git bundle file (string)
+@type str
-@return list of heads (list of strings)
+@param bundleFile file name of a git bundle file
+@type str
+@return list of heads
+@rtype list of str
 """
 args = self.initCommand("bundle")
 args.append("list-heads")
 args.append(bundleFile)
 def gitBundleFetch(self, projectDir):
 """
 Public method to fetch a head of a bundle file into the local
 repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitApplyBundleDataDialog import GitApplyBundleDataDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitBundlePull(self, projectDir):
 """
 Public method to pull a head of a bundle file into the local
 repository and working area.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating, that the update contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 from .GitApplyBundleDataDialog import GitApplyBundleDataDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitBisect(self, projectDir, subcommand):
 """
 Public method to perform bisect commands.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param subcommand name of the subcommand (string, one of 'start',
+@type str
+@param subcommand name of the subcommand (one of 'start',
 'start_extended', 'good', 'bad', 'skip' or 'reset')
-@return flag indicating, that the update contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 @exception ValueError raised to indicate an invalid bisect subcommand
 """
 from .GitBisectStartDialog import GitBisectStartDialog
 from .GitRevisionSelectionDialog import GitRevisionSelectionDialog
 def gitBisectLogBrowser(self, projectDir):
 """
 Public method used to browse the bisect log of the project.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitBisectLogBrowserDialog import GitBisectLogBrowserDialog
 if self.bisectlogBrowser is None:
 self.bisectlogBrowser = GitBisectLogBrowserDialog(self)
 def gitBisectCreateReplayFile(self, projectDir):
 """
 Public method used to create a bisect replay file for the project.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitBisectEditReplayFile(self, projectDir):
 """
 Public method used to edit a bisect replay file.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitBisectReplay(self, projectDir):
 """
 Public method to replay a bisect session.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating, that the update contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the update contained an add or delete
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitGetRemotesList(self, repodir):
 """
 Public method to get the list of remote repos.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@return list of remote repos (list of string)
+@type str
+@return list of remote repos
+@rtype list of str
 """
 args = self.initCommand("remote")
 output = ""
 process = QProcess()
 def gitGetRemoteUrlsList(self, repodir, forFetch=True):
 """
 Public method to get the list of remote repos and their URLs.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@param forFetch flag indicating to get Fetch info (string)
+@type str
-@return list of tuples of remote repo name and repo URL (list of
+@param forFetch flag indicating to get Fetch info
-tuple of two strings)
+@type str
+@return list of tuples of remote repo name and repo URL
+@rtype list of [(str, str)]
 """
 args = self.initCommand("remote")
 args.append("--verbose")
 output = ""
 def gitGetRemoteBranchesList(self, repodir, remote):
 """
 Public method to get the list of a remote repository branches.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@param remote remote repository name (string)
+@type str
-@return list of remote repository branches (list of string)
+@param remote remote repository name
+@type str
+@return list of remote repository branches
+@rtype list of str
 """
 args = self.initCommand("ls-remote")
 args.append("--heads")
 args.append(remote)
 def gitShowRemote(self, projectDir, remoteName):
 """
 Public method to show information about a remote repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param remoteName name of the remote repository (string)
+@type str
+@param remoteName name of the remote repository
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitShowRemotes(self, projectDir):
 """
 Public method to show available remote repositories.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitRemoteRepositoriesDialog import GitRemoteRepositoriesDialog
 if self.remotesDialog is None:
 self.remotesDialog = GitRemoteRepositoriesDialog(self)
 def gitAddRemote(self, projectDir):
 """
 Public method to add a remote repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitAddRemoteDialog import GitAddRemoteDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitRenameRemote(self, projectDir, remoteName):
 """
 Public method to rename a remote repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param remoteName name of the remote repository (string)
+@type str
+@param remoteName name of the remote repository
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitRemoveRemote(self, projectDir, remoteName):
 """
 Public method to remove a remote repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param remoteName name of the remote repository (string)
+@type str
+@param remoteName name of the remote repository
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitPruneRemote(self, projectDir, remoteName):
 """
 Public method to prune stale remote-tracking branches.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param remoteName name of the remote repository (string)
+@type str
+@param remoteName name of the remote repository
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitShortlog(self, projectDir, commit):
 """
 Public method to show a short log suitable for inclusion in release
 announcements.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param commit commit to start the log at (strings)
+@type str
+@param commit commit to start the log at
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitDescribe(self, projectDir, commits):
 """
 Public method to find the most recent tag reachable from each commit.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 @param commits list of commits to start the search from
-(list of strings)
+@type list of str
 """
 from .GitDescribeDialog import GitDescribeDialog
 if self.describeDialog is None:
 self.describeDialog = GitDescribeDialog(self)
 def gitCherryPick(self, projectDir, commits=None):
 """
 Public method to cherry pick commits and apply them to the current
 branch.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param commits list of commits to be applied (list of strings)
+@type str
-@return flag indicating that the project should be reread (boolean)
+@param commits list of commits to be applied
+@type list of str
+@return flag indicating that the project should be reread
+@rtype bool
 """
 from .GitCherryPickDialog import GitCherryPickDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitCherryPickContinue(self, projectDir):
 """
 Public method to continue the last copying session after conflicts
 were resolved.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating that the project should be reread (boolean)
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitCherryPickQuit(self, projectDir):
 """
 Public method to quit the current copying operation.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating that the project should be reread (boolean)
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitCherryPickAbort(self, projectDir):
 """
 Public method to cancel the last copying session and return to
 the previous state.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating that the project should be reread (boolean)
+@type str
+@return flag indicating that the project should be reread
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def __gitGetStashesList(self, projectDir):
 """
 Private method to get a list of stash names.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return list of available stashes (list of string)
+@type str
+@return list of available stashes
+@rtype list of str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return []
 def gitStashSave(self, projectDir):
 """
 Public method to save the current changes to a new stash.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating, that the save contained an add
+@type str
-or delete (boolean)
+@return flag indicating, that the save contained an add or delete
+@rtype bool
 """
 from .GitStashDataDialog import GitStashDataDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitStashBrowser(self, projectDir):
 """
 Public method used to browse the stashed changes.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitStashBrowserDialog import GitStashBrowserDialog
 if self.stashBrowser is None:
 self.stashBrowser = GitStashBrowserDialog(self)
 def gitStashShowPatch(self, projectDir, stashName=""):
 """
 Public method to show the contents of a stash.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param stashName name of a stash (string)
+@type str
+@param stashName name of a stash
+@type str
 """
 from .GitDiffDialog import GitDiffDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 def gitStashApply(self, projectDir, stashName=""):
 """
 Public method to apply a stash but keep it.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param stashName name of a stash (string)
+@type str
-@return flag indicating, that the restore contained an add
+@param stashName name of a stash
-or delete (boolean)
+@type str
+@return flag indicating, that the restore contained an add or delete
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitStashPop(self, projectDir, stashName=""):
 """
 Public method to apply a stash and delete it.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param stashName name of a stash (string)
+@type str
-@return flag indicating, that the restore contained an add
+@param stashName name of a stash
-or delete (boolean)
+@type str
+@return flag indicating, that the restore contained an add or delete
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitStashBranch(self, projectDir, stashName=""):
 """
 Public method to create a branch from a stash.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param stashName name of a stash (string)
+@type str
-@return flag indicating, that the restore contained an add
+@param stashName name of a stash
-or delete (boolean)
+@type str
+@return flag indicating, that the restore contained an add or delete
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitStashDrop(self, projectDir, stashName=""):
 """
 Public method to delete a stash.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@param stashName name of a stash (string)
+@type str
-@return flag indicating a successful deletion (boolean)
+@param stashName name of a stash
+@type str
+@return flag indicating a successful deletion
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitStashClear(self, projectDir):
 """
 Public method to delete all stashes.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
-@return flag indicating a successful deletion (boolean)
+@type str
+@return flag indicating a successful deletion
+@rtype bool
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return False
 def gitEditConfig(self, projectDir):
 """
 Public method used to edit the repository configuration file.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitShowConfig(self, projectDir):
 """
 Public method to show the combined configuration.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitVerify(self, projectDir):
 """
 Public method to verify the connectivity and validity of objects
 of the database.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitHouseKeeping(self, projectDir):
 """
 Public method to cleanup and optimize the local repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitStatistics(self, projectDir):
 """
 Public method to show some statistics of the local repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 if not repodir:
 return
 def gitGetArchiveFormats(self, repodir):
 """
 Public method to get a list of supported archive formats.
-@param repodir directory name of the repository (string)
+@param repodir directory name of the repository
-@return list of supported archive formats (list of strings)
+@type str
+@return list of supported archive formats
+@rtype list of str
 """
 args = self.initCommand("archive")
 args.append("--list")
 output = ""
 def gitCreateArchive(self, projectDir):
 """
 Public method to show some statistics of the local repository.
-@param projectDir name of the project directory (string)
+@param projectDir name of the project directory
+@type str
 """
 from .GitArchiveDataDialog import GitArchiveDataDialog
 # find the root of the repo
 repodir = self.findRepoRoot(projectDir)
 """
 Public method to instantiate a helper object for the different
 project browsers.
 @param browser reference to the project browser object
+@type ProjectBaseBrowser
 @param project reference to the project object
+@type Project
 @param isTranslationsBrowser flag indicating, the helper is requested
 for the translations browser (this needs some special treatment)
+@type bool
 @return the project browser helper object
+@rtype GitProjectBrowserHelper
 """
 from .ProjectBrowserHelper import GitProjectBrowserHelper
 return GitProjectBrowserHelper(self, browser, project, isTranslationsBrowser)
 def vcsGetProjectHelper(self, project):
 """
 Public method to instantiate a helper object for the project.
 @param project reference to the project object
+@type Project
 @return the project helper object
+@rtype GitProjectHelper
 """
 self.__projectHelper = self.__plugin.getProjectHelper()
 self.__projectHelper.setObjects(self, project)
 return self.__projectHelper
 """
 Protected method to create an instance of the VCS status monitor
 thread.
 @param interval check interval for the monitor thread in seconds
-(integer)
+@type int
-@param project reference to the project object (Project)
+@param project reference to the project object
-@return reference to the monitor thread (QThread)
+@type Project
+@return reference to the monitor thread
+@rtype GitStatusMonitorThread
 """
 from .GitStatusMonitorThread import GitStatusMonitorThread
 return GitStatusMonitorThread(interval, project, self)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Plugins/VcsPlugins/vcsGit/git.py

src/eric7/Plugins/VcsPlugins/vcsGit/git.py