mercurial-crew-with-dirclash: comparison contrib/vim/hgcommand.txt

equal deleted inserted replaced

-:61f2008cd6bf
+:457846f400e8
-*cvscommand.txt*	CVSCommand
+*hgcommand.txt*	HGCommand
 For instructions on installing this file, type
 	:help add-local-help
 inside Vim.
-Author:  Bob Hiestand <bob.hiestand@gmail.com>
+Author:  Mathieu Clabaut <mathieu.clabaut@gmail.com>
-Credits:  Benji Fisher's excellent MatchIt documentation
+Credits:  Bob Hiestand <bob.hiestand@gmail.com>
 ==============================================================================
-1. Contents						*cvscommand-contents*
+1. Contents						*hgcommand-contents*
-	Installation		: |cvscommand-install|
+	Installation		: |hgcommand-install|
-	CVSCommand Intro	: |cvscommand|
+HGCommand Intro	        : |hgcommand|
-	CVSCommand Manual	: |cvscommand-manual|
+	HGCommand Manual	: |hgcommand-manual|
-	Customization		: |cvscommand-customize|
+	Customization		: |hgcommand-customize|
-	SSH "integration"	: |cvscommand-ssh|
+	SSH "integration"	: |hgcommand-ssh|
-	Bugs			: |cvscommand-bugs|
+	Bugs			: |hgcommand-bugs|
 ==============================================================================
-2. CVSCommand Installation				*cvscommand-install*
+2. HGCommand Installation				*hgcommand-install*
-The CVSCommand plugin comprises two files, cvscommand.vim and cvscommand.txt
+The HGCommand plugin comprises two files, hgcommand.vim and hgcommand.txt
-(this file).  In order to install the plugin, place the cvscommand.vim file
+(this file).  In order to install the plugin, place the hgcommand.vim file
 into a plugin' directory in your runtime path (please see |add-global-plugin|
 and |'runtimepath'|.
-CVSCommand may be customized by setting variables, creating maps, and
+HGCommand may be customized by setting variables, creating maps, and
-specifying event handlers.  Please see |cvscommand-customize| for more
+specifying event handlers.  Please see |hgcommand-customize| for more
 details.
 This help file can be included in the VIM help system by copying it into a
 'doc' directory in your runtime path and then executing the |:helptags|
 command, specifying the full path of the 'doc' directory.  Please see
 |add-local-help| for more details.
 ==============================================================================
-3. CVSCommand Intro					*cvscommand*
+3. HGCommand Intro					*hgcommand*
-							*cvscommand-intro*
+							*hgcommand-intro*
-The CVSCommand plugin provides global ex commands for manipulating
+The HGCommand plugin provides global ex commands for manipulating
-CVS-controlled source files.  In general, each command operates on the current
+HG-controlled source files.  In general, each command operates on the current
-buffer and accomplishes a separate cvs function, such as update, commit, log,
+buffer and accomplishes a separate hg function, such as update, commit, log,
-and others (please see |cvscommand-commands| for a list of all available
+and others (please see |hgcommand-commands| for a list of all available
 commands).  The results of each operation are displayed in a scratch buffer.
 Several buffer variables are defined for those scratch buffers (please see
-|cvscommand-buffer-variables|).
+|hgcommand-buffer-variables|).
 The notion of "current file" means either the current buffer, or, in the case
 of a directory buffer, the file on the current line within the buffer.
-For convenience, any CVSCommand invoked on a CVSCommand scratch buffer acts as
+For convenience, any HGCommand invoked on a HGCommand scratch buffer acts as
 though it was invoked on the original file and splits the screen so that the
 output appears in a new window.
 Many of the commands accept revisions as arguments.  By default, most operate
 on the most recent revision on the current branch if no revision is specified
-(though see |CVSCommandInteractive| to prompt instead).
+(though see |HGCommandInteractive| to prompt instead).
-Each CVSCommand is mapped to a key sequence starting with the <Leader>
+Each HGCommand is mapped to a key sequence starting with the <Leader>
 keystroke.  The default mappings may be overridden by supplying different
 mappings before the plugin is loaded, such as in the vimrc, in the standard
 fashion for plugin mappings.  For examples, please see
-|cvscommand-mappings-override|.
+|hgcommand-mappings-override|.
-The CVSCommand plugin may be configured in several ways.  For more details,
+The HGCommand plugin may be configured in several ways.  For more details,
-please see |cvscommand-customize|.
+please see |hgcommand-customize|.
 ==============================================================================
-4. CVSCommand Manual					*cvscommand-manual*
+4. HGCommand Manual					*hgcommand-manual*
-4.1 CVSCommand commands					*cvscommand-commands*
+4.1 HGCommand commands					*hgcommand-commands*
-CVSCommand defines the following commands:
+HGCommand defines the following commands:
-|:CVSAdd|
+|:HGAdd|
-|:CVSAnnotate|
+|:HGAnnotate|
-|:CVSCommit|
+|:HGCommit|
-|:CVSDiff|
+|:HGDiff|
-|:CVSEdit|
+|:HGGotoOriginal|
-|:CVSEditors|
+|:HGLog|
-|:CVSGotoOriginal|
+|:HGRevert|
-|:CVSLog|
+|:HGReview|
-|:CVSRevert|
+|:HGStatus|
-|:CVSReview|
+|:HGUnedit|
-|:CVSStatus|
+|:HGUpdate|
-|:CVSUnedit|
+|:HGVimDiff|
-|:CVSUpdate|
-|:CVSVimDiff|
+:HGAdd							*:HGAdd*
-|:CVSWatch|
-|:CVSWatchAdd|
+This command performs "hg add" on the current file.  Please note, this does
-|:CVSWatchOn|
-|:CVSWatchOff|
-|:CVSWatchRemove|
-|:CVSWatchers|
-:CVSAdd							*:CVSAdd*
-This command performs "cvs add" on the current file.  Please note, this does
 not commit the newly-added file.
-:CVSAnnotate						*:CVSAnnotate*
+:HGAnnotate						*:HGAnnotate*
-This command performs "cvs annotate" on the current file.  If an argument is
+This command performs "hg annotate" on the current file.  If an argument is
 given, the argument is used as a revision number to display.  If not given an
 argument, it uses the most recent version of the file on the current branch.
-Additionally, if the current buffer is a CVSAnnotate buffer already, the
+Additionally, if the current buffer is a HGAnnotate buffer already, the
 version number on the current line is used.
-If the |CVSCommandAnnotateParent| variable is set to a non-zero value, the
+If the |HGCommandAnnotateParent| variable is set to a non-zero value, the
 version previous to the one on the current line is used instead.  This allows
 one to navigate back to examine the previous version of a line.
-The filetype of the CVSCommand scratch buffer is set to 'CVSAnnotate', to take
+The filetype of the HGCommand scratch buffer is set to 'HGAnnotate', to take
 advantage of the bundled syntax file.
-:CVSCommit[!]						*:CVSCommit*
+:HGCommit[!]						*:HGCommit*
-If called with arguments, this performs "cvs commit" using the arguments as
+If called with arguments, this performs "hg commit" using the arguments as
 the log message.
 If '!' is used with no arguments, an empty log message is committed.
 If called with no arguments, this is a two-step command.  The first step opens
 a buffer to accept a log message.  When that buffer is written, it is
 automatically closed and the file is committed using the information from that
 log message.  The commit can be abandoned if the log message buffer is deleted
 or wiped before being written.
-Alternatively, the mapping that is used to invoke :CVSCommit (by default
+Alternatively, the mapping that is used to invoke :HGCommit (by default
-<Leader>cc) can be used in the log message buffer to immediately commit.  This
+<Leader>hgc) can be used in the log message buffer to immediately commit.
-is useful if the |CVSCommandCommitOnWrite| variable is set to 0 to disable the
+This
+is useful if the |HGCommandCommitOnWrite| variable is set to 0 to disable the
 normal commit-on-write behavior.
-:CVSDiff						*:CVSDiff*
+:HGDiff						*:HGDiff*
-With no arguments, this performs "cvs diff" on the current file against the
+With no arguments, this performs "hg diff" on the current file against the
 current repository version.
-With one argument, "cvs diff" is performed on the current file against the
+With one argument, "hg diff" is performed on the current file against the
 specified revision.
-With two arguments, cvs diff is performed between the specified
+With two arguments, hg diff is performed between the specified
 revisions of the current file.
-This command uses the 'CVSCommandDiffOpt' variable to specify diff options.
+This command uses the 'HGCommandDiffOpt' variable to specify diff options.
 If that variable does not exist, then 'wbBc' is assumed.  If you wish to have
 no options, then set it to the empty string.
-:CVSEdit						*:CVSEdit*
+This command performs "hg edit" on the current file.
-This command performs "cvs edit" on the current file.  Yes, the output buffer
-in this case is almost completely useless.
+:HGGotoOriginal					*:HGGotoOriginal*
-:CVSEditors						*:CVSEditors*
-This command performs "cvs edit" on the current file.
-:CVSGotoOriginal					*:CVSGotoOriginal*
 This command returns the current window to the source buffer, if the current
-buffer is a CVS command output buffer.
+buffer is a HG command output buffer.
-:CVSGotoOriginal!
+:HGGotoOriginal!
-Like ":CVSGotoOriginal" but also executes :bufwipeout on all CVS command
+Like ":HGGotoOriginal" but also executes :bufwipeout on all HG command
 output buffers for the source buffer.
-:CVSLog							*:CVSLog*
+:HGLog							*:HGLog*
-Performs "cvs log" on the current file.
+Performs "hg log" on the current file.
 If an argument is given, it is passed as an argument to the "-r" option of
-"cvs log".
+"hg log".
-:CVSRevert						*:CVSRevert*
+:HGRevert						*:HGRevert*
 Replaces the current file with the most recent version from the repository in
 order to wipe out any undesired changes.
-:CVSReview						*:CVSReview*
+:HGReview						*:HGReview*
 Retrieves a particular version of the current file.  If no argument is given,
 the most recent version of the file on the current branch is retrieved.
 Otherwise, the specified version is retrieved.
-:CVSStatus						*:CVSStatus*
+:HGStatus						*:HGStatus*
-Performs "cvs status" on the current file.
+Performs "hg status" on the current file.
-:CVSUnedit						*:CVSUnedit*
+:HGUnedit						*:HGUnedit*
-Performs "cvs unedit" on the current file.  Again, yes, the output buffer here
+Performs "hg unedit" on the current file.  Again, yes, the output buffer here
 is basically useless.
-:CVSUpdate						*:CVSUpdate*
+:HGUpdate						*:HGUpdate*
-Performs "cvs update" on the current file.  This intentionally does not
+Performs "hg update" on the current file.  This intentionally does not
 automatically reload the current buffer, though vim should prompt the user to
 do so if the underlying file is altered by this command.
-:CVSVimDiff						*:CVSVimDiff*
+:HGVimDiff						*:HGVimDiff*
 With no arguments, this prompts the user for a revision and then uses vimdiff
 to display the differences between the current file and the specified
 revision.  If no revision is specified, the most recent version of the file on
 the current branch is used.
 Using the 2-argument form of the command resets the vimdiff to only those 2
 versions.  Additionally, invoking the command on a different file will close
 the previous vimdiff buffers.
-:CVSWatch						*:CVSWatch*
+4.2 Mappings						*hgcommand-mappings*
-This command takes an argument which must be one of [on|off|add|remove].  The
-command performs "cvs watch" with the given argument on the current file.
-:CVSWatchAdd						*:CVSWatchAdd*
-This command is an alias for ":CVSWatch add"
-:CVSWatchOn						*:CVSWatchOn*
-This command is an alias for ":CVSWatch on"
-:CVSWatchOff						*:CVSWatchOff*
-This command is an alias for ":CVSWatch off"
-:CVSWatchRemove						*:CVSWatchRemove*
-This command is an alias for ":CVSWatch remove"
-:CVSWatchers						*:CVSWatchers*
-This command performs "cvs watchers" on the current file.
-4.2 Mappings						*cvscommand-mappings*
 By default, a mapping is defined for each command.  These mappings execute the
 default (no-argument) form of each command.
-<Leader>ca CVSAdd
+<Leader>hga HGAdd
-<Leader>cn CVSAnnotate
+<Leader>hgn HGAnnotate
-<Leader>cc CVSCommit
+<Leader>hgc HGCommit
-<Leader>cd CVSDiff
+<Leader>hgd HGDiff
-<Leader>ce CVSEdit
+<Leader>hgg HGGotoOriginal
-<Leader>ci CVSEditors
+<Leader>hgG HGGotoOriginal!
-<Leader>cg CVSGotoOriginal
+<Leader>hgl HGLog
-<Leader>cG CVSGotoOriginal!
+<Leader>hgr HGReview
-<Leader>cl CVSLog
+<Leader>hgs HGStatus
-<Leader>cr CVSReview
+<Leader>hgt HGUnedit
-<Leader>cs CVSStatus
+<Leader>hgu HGUpdate
-<Leader>ct CVSUnedit
+<Leader>hgv HGVimDiff
-<Leader>cu CVSUpdate
-<Leader>cv CVSVimDiff
+						*hgcommand-mappings-override*
-<Leader>cwv CVSWatchers
-<Leader>cwa CVSWatchAdd
-<Leader>cwn CVSWatchOn
-<Leader>cwf CVSWatchOff
-<Leader>cwf CVSWatchRemove
-						*cvscommand-mappings-override*
 The default mappings can be overriden by user-provided instead by mapping to
 <Plug>CommandName.  This is especially useful when these mappings collide with
 other existing mappings (vim will warn of this during plugin initialization,
 but will not clobber the existing mappings).
-For instance, to override the default mapping for :CVSAdd to set it to '\add',
+For instance, to override the default mapping for :HGAdd to set it to '\add',
 add the following to the vimrc:
-nmap \add <Plug>CVSAdd
+nmap \add <Plug>HGAdd
-4.3 Automatic buffer variables			*cvscommand-buffer-variables*
+4.3 Automatic buffer variables			*hgcommand-buffer-variables*
-Several buffer variables are defined in each CVSCommand result buffer.	These
+Several buffer variables are defined in each HGCommand result buffer.	These
 may be useful for additional customization in callbacks defined in the event
-handlers (please see |cvscommand-events|).
+handlers (please see |hgcommand-events|).
 The following variables are automatically defined:
-b:cvsOrigBuffNR						*b:cvsOrigBuffNR*
+b:hgOrigBuffNR						*b:hgOrigBuffNR*
 This variable is set to the buffer number of the source file.
-b:cvscmd						*b:cvscmd*
+b:hgcmd						*b:hgcmd*
-This variable is set to the name of the cvs command that created the result
+This variable is set to the name of the hg command that created the result
 buffer.
 ==============================================================================
-5. Configuration and customization			*cvscommand-customize*
+5. Configuration and customization			*hgcommand-customize*
-							*cvscommand-config*
+							*hgcommand-config*
-The CVSCommand plugin can be configured in two ways:  by setting configuration
+The HGCommand plugin can be configured in two ways:  by setting configuration
-variables (see |cvscommand-options|) or by defining CVSCommand event handlers
+variables (see |hgcommand-options|) or by defining HGCommand event handlers
-(see |cvscommand-events|).  Additionally, the CVSCommand plugin provides
+(see |hgcommand-events|).  Additionally, the HGCommand plugin provides
-several option for naming the CVS result buffers (see |cvscommand-naming|) and
+several option for naming the HG result buffers (see |hgcommand-naming|) and
-supported a customized status line (see |cvscommand-statusline| and
+supported a customized status line (see |hgcommand-statusline| and
-|cvscommand-buffer-management|).
+|hgcommand-buffer-management|).
-5.1 CVSCommand configuration variables			*cvscommand-options*
+5.1 HGCommand configuration variables			*hgcommand-options*
 Several variables affect the plugin's behavior.  These variables are checked
 at time of execution, and may be defined at the window, buffer, or global
 level and are checked in that order of precedence.
 The following variables are available:
-|CVSCommandAnnotateParent|
+|HGCommandAnnotateParent|
-|CVSCommandCommitOnWrite|
+|HGCommandCommitOnWrite|
-|CVSCommandCVSExec|
+|HGCommandHGExec|
-|CVSCommandDeleteOnHide|
+|HGCommandDeleteOnHide|
-|CVSCommandDiffOpt|
+|HGCommandDiffOpt|
-|CVSCommandDiffSplit|
+|HGCommandDiffSplit|
-|CVSCommandEdit|
+|HGCommandEdit|
-|CVSCommandEnableBufferSetup|
+|HGCommandEnableBufferSetup|
-|CVSCommandInteractive|
+|HGCommandInteractive|
-|CVSCommandNameMarker|
+|HGCommandNameMarker|
-|CVSCommandNameResultBuffers|
+|HGCommandNameResultBuffers|
-|CVSCommandSplit|
+|HGCommandSplit|
-CVSCommandAnnotateParent			*CVSCommandAnnotateParent*
+HGCommandAnnotateParent			*HGCommandAnnotateParent*
 This variable, if set to a non-zero value, causes the zero-argument form of
-CVSAnnotate when invoked on a CVSAnnotate buffer to go to the version previous
+HGAnnotate when invoked on a HGAnnotate buffer to go to the version previous
 to that displayed on the current line.  If not set, it defaults to 0.
-CVSCommandCommitOnWrite				*CVSCommandCommitOnWrite*
+HGCommandCommitOnWrite				*HGCommandCommitOnWrite*
-This variable, if set to a non-zero value, causes the pending cvs commit
+This variable, if set to a non-zero value, causes the pending hg commit
 to take place immediately as soon as the log message buffer is written.
-If set to zero, only the CVSCommit mapping will cause the pending commit to
+If set to zero, only the HGCommit mapping will cause the pending commit to
 occur.	If not set, it defaults to 1.
-CVSCommandCVSExec				*CVSCommandCVSExec*
+HGCommandHGExec				*HGCommandHGExec*
-This variable controls the executable used for all CVS commands  If not set,
+This variable controls the executable used for all HG commands  If not set,
-it defaults to "cvs".
+it defaults to "hg".
-CVSCommandDeleteOnHide				*CVSCommandDeleteOnHide*
+HGCommandDeleteOnHide				*HGCommandDeleteOnHide*
-This variable, if set to a non-zero value, causes the temporary CVS result
+This variable, if set to a non-zero value, causes the temporary HG result
 buffers to automatically delete themselves when hidden.
-CVSCommandDiffOpt				*CVSCommandDiffOpt*
+HGCommandDiffOpt				*HGCommandDiffOpt*
 This variable, if set, determines the options passed to the diff command of
-CVS.  If not set, it defaults to 'wbBc'.
+HG.  If not set, it defaults to 'wbBc'.
-CVSCommandDiffSplit				*CVSCommandDiffSplit*
+HGCommandDiffSplit				*HGCommandDiffSplit*
-This variable overrides the |CVSCommandSplit| variable, but only for buffers
+This variable overrides the |HGCommandSplit| variable, but only for buffers
-created with |:CVSVimDiff|.
+created with |:HGVimDiff|.
-CVSCommandEdit					*CVSCommandEdit*
+HGCommandEdit					*HGCommandEdit*
 This variable controls whether the original buffer is replaced ('edit') or
 split ('split').  If not set, it defaults to 'edit'.
-CVSCommandEnableBufferSetup			*CVSCommandEnableBufferSetup*
+HGCommandEnableBufferSetup			*HGCommandEnableBufferSetup*
-This variable, if set to a non-zero value, activates CVS buffer management
+This variable, if set to a non-zero value, activates HG buffer management
-mode see (|cvscommand-buffer-management|).  This mode means that two buffer
+mode see (|hgcommand-buffer-management|).  This mode means that two buffer
-variables, 'CVSRevision' and 'CVSBranch', are set if the file is
+variables, 'HGRevision' and 'HGBranch', are set if the file is
-CVS-controlled.  This is useful for displaying version information in the
+HG-controlled.  This is useful for displaying version information in the
 status bar.
-CVSCommandInteractive				*CVSCommandInteractive*
+HGCommandInteractive				*HGCommandInteractive*
 This variable, if set to a non-zero value, causes appropriate commands (for
-the moment, only |:CVSReview|) to query the user for a revision to use instead
+the moment, only |:HGReview|) to query the user for a revision to use instead
 of the current revision if none is specified.
-CVSCommandNameMarker				*CVSCommandNameMarker*
+HGCommandNameMarker				*HGCommandNameMarker*
 This variable, if set, configures the special attention-getting characters
-that appear on either side of the cvs buffer type in the buffer name.  This
+that appear on either side of the hg buffer type in the buffer name.  This
-has no effect unless |CVSCommandNameResultBuffers| is set to a true value.  If
+has no effect unless |HGCommandNameResultBuffers| is set to a true value.  If
 not set, it defaults to '_'.
-CVSCommandNameResultBuffers			*CVSCommandNameResultBuffers*
+HGCommandNameResultBuffers			*HGCommandNameResultBuffers*
-This variable, if set to a true value, causes the cvs result buffers to be
+This variable, if set to a true value, causes the hg result buffers to be
-named in the old way ('<source file name> _<cvs command>_').  If not set
+named in the old way ('<source file name> _<hg command>_').  If not set
 or set to a false value, the result buffer is nameless.
-CVSCommandSplit					*CVSCommandSplit*
+HGCommandSplit					*HGCommandSplit*
 This variable controls the orientation of the various window splits that
-may occur (such as with CVSVimDiff, when using a CVS command on a CVS
+may occur (such as with HGVimDiff, when using a HG command on a HG
-command buffer, or when the |CVSCommandEdit| variable is set to 'split'.
+command buffer, or when the |HGCommandEdit| variable is set to 'split'.
 If set to 'horizontal', the resulting windows will be on stacked on top of
 one another.  If set to 'vertical', the resulting windows will be
 side-by-side.  If not set, it defaults to 'horizontal' for all but
-CVSVimDiff windows.
+HGVimDiff windows.
-5.2 CVSCommand events				*cvscommand-events*
+5.2 HGCommand events				*hgcommand-events*
-For additional customization, CVSCommand can trigger user-defined events.
+For additional customization, HGCommand can trigger user-defined events.
 Event handlers are provided by defining User event autocommands (see
-|autocommand|, |User|) in the CVSCommand group with patterns matching the
+|autocommand|, |User|) in the HGCommand group with patterns matching the
 event name.
 For instance, the following could be added to the vimrc to provide a 'q'
-mapping to quit a CVSCommand scratch buffer:
+mapping to quit a HGCommand scratch buffer:
-augroup CVSCommand
+augroup HGCommand
-au CVSCommand User CVSBufferCreated silent! nmap <unique> <buffer> q: bwipeout<cr>
+au HGCommand User HGBufferCreated silent! nmap <unique> <buffer> q: bwipeout<cr>
 augroup END
 The following hooks are available:
-CVSBufferCreated		This event is fired just after a cvs command
+HGBufferCreated		This event is fired just after a hg command
 				result buffer is created and filled with the
-				result of a cvs command.  It is executed within
+				result of a hg command.  It is executed within
-				the context of the CVS command buffer.  The
+				the context of the HG command buffer.  The
-				CVSCommand buffer variables may be useful for
+				HGCommand buffer variables may be useful for
 				handlers of this event (please see
-				|cvscommand-buffer-variables|).
+				|hgcommand-buffer-variables|).
-CVSBufferSetup			This event is fired just after CVS buffer setup
+HGBufferSetup			This event is fired just after HG buffer setup
 				occurs, if enabled.
-CVSPluginInit			This event is fired when the CVSCommand plugin
+HGPluginInit			This event is fired when the HGCommand plugin
 				first loads.
-CVSPluginFinish			This event is fired just after the CVSCommand
+HGPluginFinish			This event is fired just after the HGCommand
 				plugin loads.
-CVSVimDiffFinish		This event is fired just after the CVSVimDiff
+HGVimDiffFinish		This event is fired just after the HGVimDiff
 				command executes to allow customization of,
 				for instance, window placement and focus.
-5.3 CVSCommand buffer naming				*cvscommand-naming*
+5.3 HGCommand buffer naming				*hgcommand-naming*
-By default, the buffers containing the result of CVS commands are nameless
+By default, the buffers containing the result of HG commands are nameless
 scratch buffers.  It is intended that buffer variables of those buffers be
 used to customize the statusline option so that the user may fully control the
 display of result buffers.
 If the old-style naming is desired, please enable the
-|CVSCommandNameResultBuffers| variable.  Then, each result buffer will receive
+|HGCommandNameResultBuffers| variable.  Then, each result buffer will receive
-a unique name that includes the source file name, the CVS command, and any
+a unique name that includes the source file name, the HG command, and any
 extra data (such as revision numbers) that were part of the command.
-5.4 CVSCommand status line support			*cvscommand-statusline*
+5.4 HGCommand status line support			*hgcommand-statusline*
 It is intended that the user will customize the |'statusline'| option to
-include CVS result buffer attributes.  A sample function that may be used in
+include HG result buffer attributes.  A sample function that may be used in
-the |'statusline'| option is provided by the plugin, CVSGetStatusLine().  In
+the |'statusline'| option is provided by the plugin, HGGetStatusLine().  In
 order to use that function in the status line, do something like the
 following:
-set statusline=%<%f\ %{CVSGetStatusLine()}\ %h%m%r%=%l,%c%V\ %P
+set statusline=%<%f\ %{HGGetStatusLine()}\ %h%m%r%=%l,%c%V\ %P
-of which %{CVSGetStatusLine()} is the relevant portion.
+of which %{HGGetStatusLine()} is the relevant portion.
-The sample CVSGetStatusLine() function handles both CVS result buffers and
+The sample HGGetStatusLine() function handles both HG result buffers and
-CVS-managed files if CVSCommand buffer management is enabled (please see
+HG-managed files if HGCommand buffer management is enabled (please see
-|cvscommand-buffer-management|).
+|hgcommand-buffer-management|).
-5.5 CVSCommand buffer management		*cvscommand-buffer-management*
+5.5 HGCommand buffer management		*hgcommand-buffer-management*
-The CVSCommand plugin can operate in buffer management mode, which means that
+The HGCommand plugin can operate in buffer management mode, which means that
-it attempts to set two buffer variables ('CVSRevision' and 'CVSBranch') upon
+it attempts to set two buffer variables ('HGRevision' and 'HGBranch') upon
-entry into a buffer.  This is rather slow because it means that 'cvs status'
+entry into a buffer.  This is rather slow because it means that 'hg status'
 will be invoked at each entry into a buffer (during the |BufEnter|
 autocommand).
 This mode is disabled by default.  In order to enable it, set the
-|CVSCommandEnableBufferSetup| variable to a true (non-zero) value.  Enabling
+|HGCommandEnableBufferSetup| variable to a true (non-zero) value.  Enabling
 this mode simply provides the buffer variables mentioned above.  The user must
 explicitly include those in the |'statusline'| option if they are to appear in
-the status line (but see |cvscommand-statusline| for a simple way to do that).
+the status line (but see |hgcommand-statusline| for a simple way to do that).
 ==============================================================================
-6. SSH "integration"					*cvscommand-ssh*
+6. SSH "integration"					*hgcommand-ssh*
 The following instructions are intended for use in integrating the
-cvscommand.vim plugin with an SSH-based CVS environment.
+hgcommand.vim plugin with an SSH-based HG environment.
-Familiarity with SSH and CVS are assumed.
+Familiarity with SSH and HG are assumed.
 These instructions assume that the intent is to have a message box pop up in
 order to allow the user to enter a passphrase.  If, instead, the user is
 comfortable using certificate-based authentication, then only instructions
 6.1.1 and 6.1.2 (and optionally 6.1.4) need to be followed; ssh should then
 work transparently.
-6.1 Environment settings				*cvscommand-ssh-env*
+6.1 Environment settings				*hgcommand-ssh-env*
-6.1.1 CVSROOT should be set to something like:
+6.1.1 HGROOT should be set to something like:
 	:ext:user@host:/path_to_repository
-6.1.2 CVS_RSH should be set to:
+6.1.2 HG_RSH should be set to:
 	ssh
-	Together, those settings tell CVS to use ssh as the transport when
+	Together, those settings tell HG to use ssh as the transport when
-	performing CVS calls.
+	performing HG calls.
 6.1.3 SSH_ASKPASS should be set to the password-dialog program.  In my case,
 	running gnome, it's set to:
 	/usr/libexec/openssh/gnome-ssh-askpass
 	This tells SSH how to get passwords if no input is available.
-6.1.4 OPTIONAL.  You may need to set SSH_SERVER to the location of the cvs
+6.1.4 OPTIONAL.  You may need to set SSH_SERVER to the location of the hg
 	executable on the remote (server) machine.
-6.2 CVS wrapper program				*cvscommand-ssh-wrapper*
+6.2 HG wrapper program				*hgcommand-ssh-wrapper*
 Now you need to convince SSH to use the password-dialog program.  This means
-you need to execute SSH (and therefore CVS) without standard input.  The
+you need to execute SSH (and therefore HG) without standard input.  The
-following script is a simple perl wrapper that dissasociates the CVS command
+following script is a simple perl wrapper that dissasociates the HG command
 from the current terminal.  Specific steps to do this may vary from system to
 system; the following example works for me on linux.
 #!/usr/bin/perl -w
 use strict;
 use POSIX qw(setsid);
 open STDIN, '/dev/null';
 fork and do {wait; exit;};
 setsid;
-exec('cvs', @ARGV);
+exec('hg', @ARGV);
-6.3 Configuring cvscommand.vim			*cvscommand-ssh-config*
+6.3 Configuring hgcommand.vim			*hgcommand-ssh-config*
-At this point, you should be able to use your wrapper script to invoke CVS with
+At this point, you should be able to use your wrapper script to invoke HG with
-various commands, and get the password dialog.  All that's left is to make CVS
+various commands, and get the password dialog.  All that's left is to make HG
 use your newly-created wrapper script.
-6.3.1 Tell cvscommand.vim what CVS executable to use.  The easiest way to do this
+6.3.1 Tell hgcommand.vim what HG executable to use.  The easiest way to do this
 	is globally, by putting the following in your .vimrc:
-	let CVSCommandCVSExec=/path/to/cvs/wrapper/script
+	let HGCommandHGExec=/path/to/hg/wrapper/script
-6.4 Where to go from here			*cvscommand-ssh-other*
+6.4 Where to go from here			*hgcommand-ssh-other*
-The script given above works even when non-SSH CVS connections are used,
+The script given above works even when non-SSH HG connections are used,
-except possibly when interactively entering the message for CVS commit log
+except possibly when interactively entering the message for HG commit log
-(depending on the editor you use... VIM works fine).  Since the cvscommand.vim
+(depending on the editor you use... VIM works fine).  Since the hgcommand.vim
 plugin handles that message without a terminal, the wrapper script can be used
 all the time.
-This allows mixed-mode operation, where some work is done with SSH-based CVS
+This allows mixed-mode operation, where some work is done with SSH-based HG
 repositories, and others with pserver or local access.
 It is possible, though beyond the scope of the plugin, to dynamically set the
-CVS executable based on the CVSROOT for the file being edited.  The user
+HG executable based on the HGROOT for the file being edited.  The user
-events provided (such as CVSBufferCreated and CVSBufferSetup) can be used to
+events provided (such as HGBufferCreated and HGBufferSetup) can be used to
-set a buffer-local value (b:CVSCommandCVSExec) to override the CVS executable
+set a buffer-local value (b:HGCommandHGExec) to override the HG executable
 on a file-by-file basis.  Alternatively, much the same can be done (less
 automatically) by the various project-oriented plugins out there.
 It is highly recommended for ease-of-use that certificates with no passphrase
 or ssh-agent are employed so that the user is not given the password prompt
 too often.
 ==============================================================================
-9. Tips							*cvscommand-tips*
+9. Tips							*hgcommand-tips*
 9.1 Split window annotation, by Michael Anderson
-:nmap <Leader>cN :vs<CR><C-w>h<Leader>cn:vertical res 40<CR>
+:nmap <Leader>hgN :vs<CR><C-w>h<Leader>hgn:vertical res 40<CR>
 \ggdddd:set scb<CR>:set nowrap<CR><C-w>lgg:set scb<CR>
 \:set nowrap<CR>
 This splits the buffer vertically, puts an annotation on the left (minus the
 header) with the width set to 40. An editable/normal copy is placed on the
 2) You can still edit your own code.
 3) Your own code still has syntax highlighting.
 ==============================================================================
-8. Known bugs						*cvscommand-bugs*
+8. Known bugs						*hgcommand-bugs*
 Please let me know if you run across any.
-CVSUnedit may, if a file is changed from the repository, provide prompt text
+HGVimDiff, when using the original (real) source buffer as one of the diff
-to determine whether the changes should be thrown away.  Currently, that text
-shows up in the CVS result buffer as information; there is no way for the user
-to actually respond to the prompt and the CVS unedit command does nothing.  If
-this really bothers anyone, please let me know.
-CVSVimDiff, when using the original (real) source buffer as one of the diff
 buffers, uses some hacks to try to restore the state of the original buffer
 when the scratch buffer containing the other version is destroyed.  There may
 still be bugs in here, depending on many configuration details.
 vim:tw=78:ts=8:ft=help

changeset 2592	457846f400e8
parent 2591	61f2008cd6bf