mhoward/dotfiles: comparison .hgext/hgflow.py

-:7e6e6ff35c4d
+:ba72a71f23e6
+"""commands to support generalized Driessen's branching model
+"""
+# License GPL 2.0
+#
+# hgflow.py - Mercurial extension to support generalized Driessen's branching model
+# Copyright (C) 2011-2012, Yujie Wu
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the License or any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+import os
+import sys
+import copy
+import difflib
+import mercurial
+from mercurial import util, extensions, error, config
+from mercurial.node import short
+from mercurial.i18n import _
+###############################################################################################################################
+# Let's use 128 char width.
+# It is silly to stick to the 80-char rule.
+#
+#
+# Terminologies  <== Read before you got confused
+#   - branch type
+#     We distinguish the following types of branches: master, develop, feature, release, hotfix, support.
+#     We should assume any branch is of one of these types.
+#
+#   - stream
+#     The entire set of branches of the same type. Stream is not branch, it is a set. Stream is not a type, it is a set.
+#     Stream is a set of branches.
+#
+#   - substream
+#     A subset of branches in a stream.
+#
+#   - trunk
+#     Trunk is a special branch. A stream can optionally have a trunk, but only one trunk at most. For example, master and
+#     develop streams each has a trunk, whereas feature, release, hotfix, and support streams don't.
+#     If a stream has a trunk, all branches in the stream normally should diverge from the trunk and later merge to the trunk
+#     when the branches are closed.
+#     Trunk is a relative concept. A trunk of a stream may be a regular branch of another stream. (The former stream will be
+#     a substream of the latter.)
+#
+#   - source
+#     Source is an attribute of stream. The source of a stream refers to the parent stream where branches in the current stream
+#     are created from. Most commonly, source of a stream is the stream itself. But this is not always the case, for example,
+#     the sources of release and feature streams are the develop stream.
+#
+#   - destin
+#     Destin is another attribute of stream. The destin of a stream refers to the stream(s) where branches in the current
+#     stream will merge to. Most commonly, destin of a stream is the stream itself. But this is not always the case, for
+#     example, the destin of release is the develop and the master streams.
+#
+#   - branch name
+#     Use this term carefully since it is potentially ambiguious.
+#     Try using this term to refer to fullname (see below).
+#
+#   - fullname
+#     Branch name as recognized by the SCM, e.g., feature/enhance_log.
+#     Prefer this term to 'branch name'.
+#
+#   - basename
+#     Branch name recognized by flow, but not necessarily by SCM, e.g., enhanced_log (with prefix 'feature/' dropped).
+#
+#   - name
+#     Use this term carefully since it is potentially ambiguious.
+#     This term should be a synonym of basename (see above). Try using it only as place holders, such as
+#     <hotfix-prefix>/<name>.
+#
+#   - flow action
+#     Refer to action on a specified stream, e.g., hg flow feature start, where 'start' is an action.
+#
+#   - flow command
+#     Refer to other actions than those on a stream, e.g., hg flow unshelve, where 'unshelve' is a command.
+#
+#   - hg command
+#     Refer to command not from flow extension.
+#
+#   - workflow
+#     Refer to the process of executing a sequence of hg commands.
+#
+#   - history
+#     Refer to a sequence of hg commands that has been executed.
+#
+# Notations
+#   - <stream>
+#     Examples: <feature>, <hotfix>. These denote the corresponding streams. When you refer to a stream, e.g., feature stream,
+#     use '<feature>' (or more verbosely 'feature stream'), instead of '<feature> stream', because '<feature>' already means
+#     stream.
+#
+#   - <stream> branch
+#     Example: a <feature> branch. This phrase refers a branch in <feature>. Do not use 'a feature branch' to mean a branch in
+#     <feature> because the word 'feature' there should take its usual meaning as in English, which doesn't necessarily mean
+#     the feature stream.
+#
+#   - `text`
+#     Example, `hg flow feature start <name>`. The text wrapped by the ` (apostrophe) symbols should be a piece of code or
+#     shell command, which could contain placeholders to be replaced by actual values.
+#
+#   - 'text' or "text"
+#     Refer to an exact string.
+###############################################################################################################################
+VERSION                   = "0.9.7"
+CONFIG_BASENAME           = ".hgflow"
+OLD_CONFIG_BASENAME       = ".flow"
+CONFIG_SECTION_BRANCHNAME = "branchname"
+STRIP_CHARS               = '\'"'
+colortable = {"flow.error"      : "red bold",
+"flow.warn"       : "magenta bold",
+"flow.note"       : "cyan",
+"flow.help.topic" : "yellow",
+"flow.help.code"  : "green bold",
+}
+def _print( ui, *arg, **kwarg ) :
+"""
+Customized print function
+This function prints messages with the prefix: C{flow: }. Multiple messages can be printed in one call.
+See I{Example I} below.
+@type  ui:      C{mercurial.ui}
+@param ui:      Mercurial user interface object
+@type  warning: C{bool}
+@param warning: If set to true, messages will be written to C{stderr} using the C{ui.warn} function.
+@type  note:    C{bool}
+@param note:    If set to true, messages will be written to C{stdout} using the C{ui.note} function. The messages will be
+visible only when user turns on C{--verbose}.
+By default, both L{warning} and L{note} are set to false, and messages will be written to C{stdout}.
+@type  prefix:  C{None} or C{str}
+@param prefix:  Add a customized prefix before every message. See I{Example II}.
+@type  newline: C{bool}
+@param newline: If set to false, each message will be written without newline suffix. Default value is true.
+I{Example I}:
+>>> _print( ui, "message1", "message2" )
+flow: message1
+flow: message2
+I{Example II}:
+>>> _print( ui, "message1", "message2", prefix = "warning: " )
+flow: warning: message1
+flow: warning: message2
+I{Example III}:
+>>> _print( ui, "message1", "message2", inline = False )
+flow: message1message2
+"""
+printer = ui.warn if (kwarg.get( "warning" )) else (ui.note if (kwarg.get( "note" )) else ui.write)
+indent  = kwarg.get( "indent", "" )
+prefix  = kwarg.get( "prefix", "" )
+newline = kwarg.get( "newline" )
+newline = "\n" if (newline or newline is None) else ""
+for e in arg :
+printer( ui.config( "flow", "prefix", "flow: " ).strip( STRIP_CHARS ) + prefix + indent )
+printer( e + newline, label = kwarg.get( "label", "" ) )
+def _warn( ui, *arg, **kwarg ) :
+"""
+Print messages to C{stderr}. Each message will be prefixed with C{flow: warning: }.
+This function is a thin wrapper of L{_print}. See document of the later for usage detail.
+Customized prefix will be appended after C{flow: warning: }.
+I{Example}:
+>>> _warn( ui, "message1", "message2", prefix = "prefix_" )
+flow: warning: prefix_message1
+flow: warning: prefix_message2
+"""
+kwarg["warn"  ] = True
+kwarg["label" ] = kwarg.get( "label", "flow.warn" )
+kwarg["prefix"] = "warning: " + kwarg.get( "prefix", "" )
+_print( ui, *arg, **kwarg )
+def _error( ui, *arg, **kwarg ) :
+"""
+Print messages to C{stderr}. Each message will be prefixed with C{flow: error: }.
+This function is a thin wrapper of L{_print}. See document of the later for usage detail.
+Customized prefix will be appended after C{flow: error: }.
+I{Example}:
+>>> _error( ui, "message1", "message2", prefix = "prefix_" )
+flow: error: prefix_message1
+flow: error: prefix_message2
+"""
+kwarg["warn"  ] = True
+kwarg["label" ] = kwarg.get( "label", "flow.error" )
+kwarg["prefix"] = "error: " + kwarg.get( "prefix", "" )
+_print( ui, *arg, **kwarg )
+def _note( ui, *arg, **kwarg ) :
+"""
+Print messages to C{stout}. Each message will be prefixed with C{flow: note: }. The messages will be displayed only when
+user turns on C{--verbose}. If you want to print message without C{--verbose}, include an argument C{via_quiet = True} in
+the call to this function.
+This function is a thin wrapper of L{_print}. See document of the later for usage detail.
+Customized prefix will be appended after C{flow: note: }.
+I{Example}:
+>>> _note( ui, "message1", "message2", prefix = "prefix_" )
+flow: note: prefix_message1
+flow: note: prefix_message2
+"""
+if (kwarg.get( "via_quiet")) :
+kwarg["note"] = not kwarg["via_quiet"]
+del kwarg["via_quiet"]
+else :
+kwarg["note"] = True
+kwarg["label" ] = kwarg.get( "label", "flow.note" )
+kwarg["prefix"] = "note: " + kwarg.get( "prefix", "" )
+_print( ui, *arg, **kwarg )
+class AbortFlow( Exception ) :
+"""
+Throw an instance of this exception whenever we have to abort the flow command.
+"""
+def __init__( self, *arg, **kwarg ) :
+"""
+Accept one or more error messages in C{str} as the arguments.
+"""
+Exception.__init__( self, "Aborted hg flow command." )
+self._msg = arg
+for k in kwarg :
+self.__dict__[k] = kwarg[k]
+def error_message( self ) :
+"""
+Returns a list of error messages in C{str}.
+"""
+return self._msg
+class AbnormalStream( Exception ) :
+"""
+Throw an instance of this exception if the stream does not belong to any one of C{<master>}, C{<develop>}, C{<feature>},
+C{<release>}, C{<hotfix>}, and C{<support>}.
+"""
+def __init__( self, message = "", stream = None ) :
+"""
+Accept one error message. You can also pass the C{Stream} object, which can be retrieved later via the C{stream}
+method.
+"""
+Exception.__init__( self, message )
+self._stream = stream
+def stream( self ) :
+"""
+Return the C{Stream} object.
+"""
+return self._stream
+class Commands( object ) :
+"""
+Wrapper class of C{mercurial.commands} with ability of recording command history.
+I{Example:}
+>>> commands = Commands()
+>>> commands.commit( ui, repo, ... )
+>>> commands.update( ui, repo, ... )
+>>> commands.print_history()
+flow: note: Hg command history:
+flow: note:   hg commit --message "flow: Closed release 0.7." --close_branch
+flow: note:   hg update default
+"""
+def __init__( self ) :
+self.ui           = None
+self._cmd         = None
+self._cmd_history = []
+self._via_quiet   = False
+self._dryrun      = False
+self._common_opts = {}
+self._opt_mutator = {}
+def __getattr__( self, name ) :
+"""
+Typical invocation of mercurial commands is in the form: commands.name( ... ).
+We only need to save the command name here, leaving execution of the command to the L{__call__} function.
+"""
+if (name[0] != "_") :
+self._cmd = name
+return self
+def __call__( self, ui, repo, *arg, **kwarg ) :
+"""
+Invoke the mercurial command and save it as a string into the history.
+@raise AbortFlow: Throw exception if the return code of hg command (except C{commit} and C{rebase}) is nonzero.
+"""
+self.ui = ui
+cmd_str = "hg " + (self._cmd[:-1] if (self._cmd[-1] == "_") else self._cmd)
+arg     = self._branch2str(   arg )
+kwarg   = self._branch2str( kwarg )
+cmd     = self._cmd
+if (cmd[0] == "q") :
+where = extensions.find( "mq" )
+cmd   = cmd[1:]
+elif (cmd == "strip" ) : where = extensions.find( "mq"     )
+elif (cmd == "rebase") : where = extensions.find( "rebase" )
+else                   : where = mercurial.commands
+kwarg = self._mutate_options( where, self._cmd, kwarg )
+for key, value in kwarg.items() :
+if (value in [None, ""]) :
+continue
+# If the command is `hg commit --message <commit-hint> --force-editor [other-options...]`, we will drop the
+# `--message <commit-hint> --force-editor` part from the command string because `--force-editor` is not a command
+# option (it avails only programmatically).
+if (cmd == "commit" and (key in ["message", "force_editor",]) and "force_editor" in kwarg) :
+continue
+new_key = ""
+for e in key :
+new_key += "-" if (e == "_") else e
+key   = new_key
+value = [self._add_quotes( e ) for e in value] if (isinstance( value, list )) else self._add_quotes( value )
+if (isinstance( value, bool )) :
+cmd_str = "%s --%s" % (cmd_str, key,)
+elif (isinstance( value, list )) :
+for e in value :
+cmd_str = "%s --%s %s" % (cmd_str, key, str( e ),)
+else :
+cmd_str = "%s --%s %s" % (cmd_str, key, str( value ),)
+for e in arg :
+cmd_str = '%s %s ' % (cmd_str, self._add_quotes( str( e ) ),)
+self._cmd_history.append( cmd_str )
+if (self._dryrun) :
+return
+try :
+# Ever since 2.8 the "strip" command has been moved out of the "mq" module to a new module of its own. Issue#56
+if ("strip" == cmd) :
+from mercurial import __version__
+if (__version__.version > "2.8") :
+where = extensions.find( "strip" )
+cmd   = "stripcmd"
+ret = None
+ret = getattr( where, cmd )( ui, repo, *arg, **kwarg )
+except Exception, e :
+raise AbortFlow( "Hg command failed: %s" % cmd_str, "abort: %s\n" % str( e ), traceback = sys.exc_info() )
+if (ret and cmd not in ["commit", "rebase",]) :
+# We have to make some exceptions, where nonzero return codes don't mean error. Issue#55
+if ((ret, cmd,) not in [(1, "push",),]) :
+raise AbortFlow( "Hg command failed: %s" % cmd_str, "abort: Nonzero return code from hg command\n" )
+def _add_quotes( self, value ) :
+"""
+If value is a string that contains space, slash, double quote, and parenthesis (viz: '(' or ')'), then wrap the value
+with double quotes and properly escape double-quotes and slashes in the string, returning the treated value.
+Otherwise, return the value as is.
+"""
+if (isinstance( value, str ) and (1 in [c in value for c in " ()\\\""])) :
+new_value = ""
+for c in value :
+if   (c == "\\") : new_value += "\\\\"
+elif (c == '"' ) : new_value += "\""
+else             : new_value += c
+value = '"%s"' % new_value
+return value
+def _branch2str( self, value ) :
+"""
+If C{value} is a C{Branch} object, return its fullname (C{str}); if it is not, return the object itself. Do this
+recursively if C{value} is a C{tuple}, or C{list}, or C{dict} object.
+"""
+if (isinstance( value, Branch )) :
+return value.fullname()
+if (isinstance( value, (list, tuple,) )) :
+new_value = []
+for e in value :
+new_value.append( self._branch2str( e ) )
+return new_value
+if (isinstance( value, dict )) :
+new_value = {}
+for k, v in value.items() :
+new_value[k] = self._branch2str( v )
+return new_value
+return value
+def _filter_common_options( self, where, cmd ) :
+"""
+If any common options are valid options of the command, return these options.
+@type  where: module
+@param where: Should be `mercurial.commands', or a Mercurial's plugin object.
+@type  cmd  : C{str}
+@param cmd  : command name
+"""
+ret = {}
+if (self._common_opts != {}) :
+if (cmd[-1] == "_") :
+cmd = cmd[:-1]
+junk, table = mercurial.cmdutil.findcmd( cmd, where.table if hasattr( where, "table" ) else where.cmdtable )
+opts        = [e[1] for e in table[1]]
+for e in self._common_opts :
+if (e in opts) :
+ret[e] = self._common_opts[e]
+return ret
+def _mutate_options( self, where, cmd, opts ) :
+"""
+"""
+common_opts = self._filter_common_options( where, cmd )
+common_opts.update( opts )
+opts    = common_opts
+mutator = self._opt_mutator.get( cmd )
+if (mutator) :
+opts = mutator( opts )
+return opts
+def use_quiet_channel( self, via_quiet = True ) :
+"""
+Print the history to the I{quiet} channel, where text will be displayed even when user does not specify the
+C{--verbose} option.
+"""
+self._via_quiet = via_quiet
+def use_verbose_channel( self, via_verbose = True ) :
+"""
+Print the history to the I{verbose} channel, where text will be display only when user specify the C{--verbose} option.
+"""
+self._via_quiet = not via_verbose
+def reg_common_options( self, opts ) :
+"""
+Register common options.
+@type  opts: C{dict}
+@param opts: Common options. Key = option's flag, value = option's value.
+"""
+self._common_opts.update( opts )
+def reg_option_mutator( self, cmd, mutator ) :
+"""
+Register common options.
+@type  opts: C{dict}
+@param opts: Common options. Key = option's flag, value = option's value.
+"""
+self._opt_mutator[cmd] = mutator
+def dryrun( self, switch = None ) :
+"""
+Switch the dry-run mode.
+@type  switch: C{boolean} or C{None}
+@param switch: Switch on dry-run mode if C{switch = True}, off if C{switch = False}. If C{switch} is C{None}, just
+return the current state of dry-run mode.
+"""
+if (switch is None) :
+return self._dryrun
+self._dryrun = switch
+def print_history( self ) :
+"""
+Print the command history using the L{_note} function.
+"""
+if (self.ui) :
+_note( self.ui, "Hg command history:", via_quiet = self._via_quiet )
+for e in self._cmd_history :
+_note( self.ui, e, prefix = "  ", via_quiet = self._via_quiet )
+class Stream( object ) :
+@staticmethod
+def gen( ui, repo, name, check = False ) :
+"""
+Given the name of a stream, return a C{Stream} object.
+If the name is that of one of the standard streams: master, develop, feature, release, hotfix, and support, return the
+same object as in C{STREAM}. If not, create and return a new C{stream} object. If the new object is not in the standard
+streams, an C{AbnormalStream} exception will be thrown. One can catch the exception and call its C{stream} method to
+get the object.
+@type  name : C{str}
+@param name : Name of the stream
+@type  check: C{boolean}
+@param check: If true and the stream is not a standard one, the function will check if the trunk of the stream exists
+or not and (if exists) open or not.
+@raise AbortFlow     : When C{check} is true and the trunk of the stream doesn't exist or is closed
+@raise AbnormalStream: When the stream is not in any of the standard streams
+"""
+for e in STREAM.values() :
+if (name == e.name()) :
+return e
+rootstream_name = name.split( '/', 1 )[0]
+is_normalstream = True
+if (rootstream_name in STREAM) :
+trunk  = name.replace( rootstream_name + '/', STREAM[rootstream_name].prefix(), 1 )
+stream = Stream( ui, repo, name, trunk = trunk )
+else :
+stream = Stream( ui, repo, name, trunk = name )
+is_normalstream = False
+if (check) :
+try :
+trunk = stream.trunk()
+except error.RepoLookupError :
+misspelling = difflib.get_close_matches( stream.name(), STREAM.keys(), 3, 0.7 )
+note        = "Did you mean: %s?" % " or ".join( misspelling ) if (misspelling) else None
+raise AbortFlow( "Stream not found: %s" % stream, note = note )
+if (trunk.is_closed()) :
+raise AbortFlow( "%s has been closed." % stream )
+if (not is_normalstream) :
+raise AbnormalStream( stream = Stream( ui, repo, name ) )
+return stream
+def __init__( self, ui, repo, name, **kwarg ) :
+"""
+Create a new C{Stream} object.
+@type  name  : C{str}
+@param name  : Name of the new stream
+@type  trunk : C{str} or C{None}
+@param trunk : Fullname of the trunk of the stream, or C{None}
+@type  prefix: C{str}
+@param prefix: Name prefix of branches in this stream. If not specified, it will default to C{trunk + '/'} (if C{trunk}
+is not C{None}), or C{name + '/'} if (C{trunk} is C{None}).
+@type  source: C{Stream}
+@param source: Stream where branches in this stream will be created from
+@type  destin: C{list} of C{Stream} objects
+@param destin: Streams where branches in this stream will merge to when being finished
+"""
+self.ui   = ui
+self.repo = repo
+self._name   = name
+self._trunk  = kwarg.get( "trunk"  )
+self._prefix = kwarg.get( "prefix" )
+self._source = kwarg.get( "source", self )
+self._destin = kwarg.get( "destin", [self._source,] )
+self._tcache = None    # Caches `Branch' object of the trunk because construction of a `Branch' object is very slow.
+if (self._prefix is None) :
+if (self._trunk) :
+self._prefix = self._trunk + '/'
+else :
+self._prefix = self._name + '/'
+def __str__( self ) :
+"""
+Return a string: '<stream-name>'.
+"""
+return "<%s>" % self._name
+def __cmp__( self, rhs ) :
+"""
+Compare streams by comparing their names as strings.
+"""
+lhs = self._name
+rhs = rhs ._name
+return -1 if (lhs < rhs) else (1 if (lhs > rhs) else 0)
+def __contains__( self, stranch ) :
+"""
+Return true if the C{stanch} is in this stream.
+@type  stranch: C{Stream} or C{Branch}
+@param srranch: Stream or branch which you want to test if it is in this stream
+"""
+if (isinstance( stranch, Branch )) :
+if (stranch._fullname == self._trunk) :
+return True
+return stranch._fullname.startswith( self.prefix() )
+elif (isinstance( stranch, Stream )) :
+return stranch.prefix().startswith( self.prefix() )
+return str( stranch ).startswith( self.prefix() )
+def name( self ) :
+"""
+Return the name of this stream.
+"""
+return self._name
+def trunk( self, trace = False ) :
+"""
+Return the trunk of this stream. If it has no trunk, return C{None} or the trunk of the source stream depending on the
+C{trace} parameter.
+@type  trace: C{boolean}
+@param trace: If true and this stream has no trunk, return the trunk of the source stream, and do this recursively
+until a trunk is found. If false, this function will return C{None}.
+@return: A C{Branch} object or C{None}
+"""
+if (self._tcache) :
+return self._tcache
+trunk = Branch( self.ui, self.repo, self._trunk ) if (self._trunk) else None
+if (not trunk and trace) :
+return self.source().trunk( True )
+self._tcache = trunk
+return trunk
+def prefix( self ) :
+"""
+Return the branch name prefix of this stream.
+@return: C{str}
+"""
+return self._prefix
+def source( self ) :
+"""
+Return the source stream.
+@return: C{Stream}
+"""
+return self._source
+def destin( self ) :
+"""
+Return a list of streams where branches in this stream will merge to when finished.
+@return: C{Stream}
+"""
+return self._destin
+def get_fullname( self, branch_basename ) :
+"""
+Return the fullname of a branch.
+@type  branch_basename: C{str}
+@param branch_basename: Basename of a branch in this stream
+@return: C{str}
+"""
+return self._prefix + branch_basename
+def get_branch( self, branch_basename ) :
+"""
+Create and return a new C{Branch} object with the given basename.
+@type  branch_basename: C{str}
+@param branch_basename: Basename of a branch in this stream
+@return: C{Branch}
+"""
+return Branch( self.ui, self.repo, self.get_fullname( branch_basename ) )
+def branches( self, openclosed = "open" ) :
+"""
+Return a list of branches in this stream. The list does not include the trunk.
+The returned list is sorted per branch name.
+@type  openclosed: C{str}, must be one of "open", "closed", and "all".
+@param openclosed: If the value is C{"open"}, return all open branches in this stream; if C{"closed"}, return all
+closed branches in this stream; if C{"all"}, returns all open and closed branches in this stream.
+"""
+if (openclosed not in ["open", "closed", "all",]) :
+raise ValueError( "Invalid value for `openclosed` parameter: %s" % openclosed )
+if (openclosed == "open") :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()
+if (not self.repo[head[0]].extra().get( "close", False ) )]
+elif (openclosed == "closed") :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()
+if (self.repo[head[0]].extra().get( "close", False ) )]
+else :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()]
+return sorted( [e for e in all_branches if (e in self)] )
+class Branch( object ) :
+def __init__( self, ui, repo, rev = None ) :
+"""
+Create a C{Branch} object with the given C{rev}.
+"""
+self.ui   = ui
+self.repo = repo
+self.ctx  = repo[rev]    # `repo[rev]' is slow when there are tens of thousands of named branches.
+self._fullname = str( self.ctx.branch() )
+def __str__( self ) :
+"""
+Return the fullname of this branch.
+"""
+return self._fullname
+def __cmp__( self, rhs ) :
+"""
+Compare two C{Branch} object by comparing their fullnames.
+"""
+if (rhs is None) :
+return 1
+lhs = self._fullname
+rhs = rhs ._fullname
+return -1 if (lhs < rhs) else (1 if (lhs > rhs) else 0)
+def fullname( self ) :
+"""
+Return the fullname of this branch.
+"""
+return self._fullname
+def basename( self, stream = None, should_quote = False ) :
+"""
+Return the basename relative to the C{stream}. If C{stream} is C{None}, return the shortest possible basename (will
+not contain any '/'s).
+Return the string "trunk" if this branch is the trunk of the C{stream}.
+@type  stream: C{Stream} or C{None}
+@param stream: Stream to which the basename is relative
+"""
+if (stream) :
+if (self._fullname == stream._trunk) :
+return "trunk"
+ret = self._fullname[len( stream.prefix() ):]
+else :
+ret = self._fullname.rsplit( '/', 1 )[-1]
+if (should_quote) :
+ret = "'%s'" % ret
+return ret
+def is_closed( self ) :
+"""
+Return true if this branch is closed; or false if it is open.
+"""
+extra = self.ctx.extra()
+try :
+return extra["close"]
+except KeyError :
+return False
+def is_open( self ) :
+"""
+Return true if this branch is open; or false if it is closed.
+"""
+return not self.is_closed()
+def is_develop_trunk( self ) :
+"""
+Return true if this branch is the trunk of C{<develop>}.
+"""
+return STREAM["develop"]._trunk == self._fullname
+def is_master_trunk( self ) :
+"""
+Return true if this branch is the trunk of C{<master>}.
+"""
+return STREAM["master"]._trunk == self._fullname
+def is_trunk( self, stream ) :
+"""
+Return true if this branch is the trunk of the C{stream}.
+"""
+return stream._trunk == self._fullname
+def stream( self ) :
+"""
+Return the stream that this branch belongs to.
+"""
+name = self._fullname
+for stream in STREAM.values() :
+if (name == stream._trunk) :
+return stream
+if (name.startswith( stream.prefix() )) :
+name = name.replace( stream.prefix(), stream.name() + '/' )
+break
+return Stream.gen( self.ui, self.repo, name.rsplit( '/', 1 )[0] )
+commands = Commands()
+STREAM   = {}           # key = stream name, value = `Stream` object. Will be set by `Flow.__init__`.
+class Flow( object ) :
+def __init__( self, ui, repo, init = False ) :
+"""
+Construct a C{Flow} instance that will execute the workflow.
+Construction will fail if the C{flow} extension has not been initialized for the repository.
+A warning message will be issued if the repository has uncommitted changes.
+@type  init: C{boolean}
+@param init: If true, a C{Flow} object will be constructed for initialization of hgflow. Such constructed object does
+not supply all functionalities and is only meant to execute the `hg flow init` command.
+"""
+self.ui   = ui
+self.repo = repo
+self.autoshelve       = False
+self.warn_uncommitted = True
+self.msg_prefix       = "flow: "
+self.version_prefix   = "v"
+self.orig_workspace   = Branch( ui, repo )
+self.curr_workspace   = self.orig_workspace     # May be changed whenever `hg update` command is executed.
+self.orig_dir         = os.getcwd()
+self._dryrun_shelve   = set()
+if (init) : return
+config_fname = os.path.join( self.repo.root, CONFIG_BASENAME )
+if (os.path.isfile( config_fname )) :
+cfg = config.config()
+cfg.read( config_fname )
+try :
+master  = cfg.get( CONFIG_SECTION_BRANCHNAME, "master"  )
+develop = cfg.get( CONFIG_SECTION_BRANCHNAME, "develop" )
+feature = cfg.get( CONFIG_SECTION_BRANCHNAME, "feature" )
+release = cfg.get( CONFIG_SECTION_BRANCHNAME, "release" )
+hotfix  = cfg.get( CONFIG_SECTION_BRANCHNAME, "hotfix"  )
+support = cfg.get( CONFIG_SECTION_BRANCHNAME, "support" )
+except Exception, e :
+self._error( str( e ) )
+self._error( "Flow has not been initialized properly for this repository." )
+self._note ( "You can use command `hg flow init -f` to reinitialize for this repository.", via_quiet = True )
+sys.exit( 1 )
+else :
+old_config_fname = os.path.join( self.repo.root, OLD_CONFIG_BASENAME )
+if (os.path.isfile( old_config_fname )) :
+cfg = config.config()
+cfg.read( old_config_fname )
+try :
+master  = cfg.get( CONFIG_SECTION_BRANCHNAME, "master"  )
+develop = cfg.get( CONFIG_SECTION_BRANCHNAME, "develop" )
+feature = cfg.get( CONFIG_SECTION_BRANCHNAME, "feature" )
+release = cfg.get( CONFIG_SECTION_BRANCHNAME, "release" )
+hotfix  = cfg.get( CONFIG_SECTION_BRANCHNAME, "hotfix"  )
+support = cfg.get( CONFIG_SECTION_BRANCHNAME, "support" )
+except Exception, e :
+self._error( str( e ) )
+self._error( "Flow has not been initialized properly for this repository." )
+self._note ( "You can use command `hg flow init -f` to reinitialize for this repository.", via_quiet = True )
+sys.exit( 1 )
+else :
+self._error( "Flow has not been initialized for this repository: %s file is missing." % CONFIG_BASENAME )
+self._note ( "You can use command `hg flow init` to initialize for this repository.", via_quiet = True )
+sys.exit( 1 )
+global STREAM
+STREAM["master" ] = Stream( ui, repo, "master",  trunk  = master  )
+STREAM["develop"] = Stream( ui, repo, "develop", trunk  = develop )
+STREAM["feature"] = Stream( ui, repo, "feature", prefix = feature, source = STREAM["develop"] )
+STREAM["release"] = Stream( ui, repo, "release", prefix = release, source = STREAM["develop"] )
+STREAM["hotfix" ] = Stream( ui, repo, "hotfix",  prefix = hotfix,  source = STREAM["master" ] )
+STREAM["support"] = Stream( ui, repo, "support", prefix = support, source = STREAM["master" ], destin = [] )
+STREAM["develop"]._destin.append( STREAM["release"] )
+STREAM["release"]._destin.append( STREAM["master" ] )
+STREAM["hotfix" ]._destin.append( STREAM["develop"] )
+if (ui.has_section( "hgflow" )) :
+self._warn( "The [hgflow] section in hg configuration file is deprecated." )
+self._warn( "Please replace the section name from [hgflow] to [flow]." )
+self.autoshelve       = ui.configbool( "hgflow", "autoshelve",       self.autoshelve        )
+self.warn_uncommitted = ui.configbool( "hgflow", "warn_uncommitted", self.warn_uncommitted  )
+if (ui.has_section( "flow" )) :
+self.autoshelve       = ui.configbool( "flow", "autoshelve",       self.autoshelve       )
+self.warn_uncommitted = ui.configbool( "flow", "warn_uncommitted", self.warn_uncommitted )
+self.msg_prefix       = ui.config    ( "flow", "prefix",           self.msg_prefix       ).strip( STRIP_CHARS )
+self.version_prefix   = ui.config    ( "flow", "version_prefix",   self.version_prefix   ).strip( STRIP_CHARS )
+if (self._has_uncommitted_changes() and self.warn_uncommitted) :
+self._warn( "Your workspace has uncommitted changes." )
+# We'd better temporarily change the current directory to the root of the repository at the beginning.
+# This is to avoid the problem that the CWD might be gone after switching to a different branch. (Issue#14)
+# We will change it back to the original directory when the hgflow command exits.
+os.chdir( self.repo.root )
+# __init__
+def __getattr__( self, name ) :
+"""
+Execute mercurial command of name C{name[1:]}.
+@type  name: C{str}
+@param name: Should be a mercurial command name prefixed with one underscore. For example, to call C{commit} command,
+use C{self._commit}.
+"""
+if (name[0] == "_") :
+cmd = getattr( commands, name[1:] )
+def func( *arg, **kwarg ) :
+cmd( self.ui, self.repo, *arg, **kwarg )
+return func
+raise AttributeError( "%s instance has no attribute '%s'" % (self.__class__, name,) )
+def _update( self, rev, *arg, **kwarg ) :
+"""
+Intercept the call to `hg update` command. We need to keep track of the branch of the workspace.
+@type  rev: C{str} or C{mercurial.changectx}
+@param rev: Revision to which the workspace will update
+"""
+try :
+old_workspace_ctx   = self.curr_workspace.ctx
+self.curr_workspace = rev if (isinstance( rev, Branch )) else Branch( self.ui, self.repo, rev )
+except error.RepoLookupError, e :
+if (commands.dryrun()) :
+commands.update( self.ui, self.repo, rev, *arg, **kwarg )
+else :
+raise e
+if (old_workspace_ctx != self.curr_workspace.ctx) :
+commands.update( self.ui, self.repo, rev, *arg, **kwarg )
+def _print( self, *arg, **kwarg ) :
+"""
+Thin wrapper of the global C{_print} function
+"""
+_print( self.ui, *arg, **kwarg )
+def _warn( self, *arg, **kwarg ) :
+"""
+Thin wrapper of the global C{_warn} function
+"""
+_warn( self.ui, *arg, **kwarg )
+def _error( self, *arg, **kwarg ) :
+"""
+Thin wrapper of the global C{_error} function
+"""
+_error( self.ui, *arg, **kwarg )
+def _note( self, *arg, **kwarg ) :
+"""
+Thin wrapper of the global C{_note} function
+"""
+_note( self.ui, *arg, **kwarg )
+def _check_rebase( self ) :
+"""
+Check if 'rebase' extension is activated. If not, raise an 'AbortFlow' exception.
+@raise AbortFlow: When 'rebase' extension is not found
+"""
+try :
+extensions.find( "rebase" )
+except KeyError :
+raise AbortFlow( "Cannot rebase without 'rebase' extension." )
+def _check_mq( self ) :
+"""
+Check if 'mq' extension is activated. If not, raise an 'AbortFlow' exception.
+@raise AbortFlow: When 'mq' extension is not found
+"""
+try :
+extensions.find( "mq" )
+except KeyError :
+raise AbortFlow( "Cannot shelve/unshelve changes without 'mq' extension." )
+def _check_strip( self ) :
+"""
+The 'strip' command comes with the 'mq' extension.
+Check if 'mq' extension is activated. If not, raise an 'AbortFlow' exception.
+@raise AbortFlow: When 'mq' extension is not found
+"""
+try :
+extensions.find( "mq" )
+except KeyError :
+raise AbortFlow( "Cannot use 'strip' command without 'mq' extension." )
+def _is_shelved( self, branch ) :
+"""
+Return true if the given branch has been shelved.
+@type  branch: C{Branch}
+@param branch: Branch to test if it has shelved changes
+"""
+shelve_name = "flow/" + branch.fullname() + ".pch"
+patch_fname = self.repo.join( "patches/" + shelve_name )
+return os.path.isfile( patch_fname )
+def _shelve( self, *arg, **kwarg ) :
+"""
+Shelve workspace if C{self.autoshelve} is C{True}.
+This function utilizes the C{mq} extension to achieve shelving. Bascially, it calls the following C{mq} commands:
+C{hg qnew <patchname> --currentuser --currentdate -m "Shelved changes"}
+C{hg qpop}
+where <patchname> follows the pattern: flow/<branch_fullname>.pch
+The two commands will give us a patch file that later will be used to unshelve the change.
+"""
+if (self.autoshelve or kwarg.get( "force" )) :
+if (self._has_uncommitted_changes()) :
+shelve_name = "flow/" + self.curr_workspace.fullname() + ".pch"
+if (commands.dryrun()) :
+# For dry run, adds the name of the shelved item into `self._dryrun_shelve'.
+# This is for generating correct dry run history for the unshelving operation.
+self._dryrun_shelve.add( shelve_name )
+self._check_mq()
+self._qnew( shelve_name, currentuser = True, currentdate = True, message = "Shelved changes" )
+self._qpop()
+def _unshelve( self, basename = None, **kwarg ) :
+"""
+Unshelve the previously shelved changes to the workspace if C{self.autoshelve} is C{True}.
+This function needs the C{mq} extension to achieve unshelving. Bascially, it calls the following commands:
+C{hg import <patch_filename> --no-commit}
+C{hg qdelete <patchname>}
+where <patchname> follows the pattern: flow/<branch_fullname>.pch, which was previously created by flow's shelving.
+@type  basename: C{str}
+@param basename: Base name of the shelved patch file. Default is the name of current workspace branch.
+"""
+if (self.autoshelve or kwarg.get( "force" )) :
+basename    = basename if (basename) else self.curr_workspace.fullname()
+shelve_name = "flow/" + basename + ".pch"
+patch_fname = self.repo.join( "patches/" + shelve_name )
+if (os.path.isfile( patch_fname ) or (shelve_name in self._dryrun_shelve)) :
+self._check_mq()
+self._import_( patch_fname, no_commit = True, base = "", strip = 1 )
+self._qdelete( shelve_name )
+if (commands.dryrun()) :
+self._dryrun_shelve.discard( shelve_name )
+def _has_uncommitted_changes( self ) :
+"""
+Return true if any tracked file is modified, or added, or removed, or deleted.
+"""
+return any( self.repo.status() )
+def _branches( self, openclosed = "open" ) :
+"""
+Return a list of branches.
+@type  openclosed: C{str}, "open", "closed", and "all"
+@param openclosed: If C{"open"}, return all open branches; if C{"closed"}, return all closed branches; if C{"all"},
+return all branches.
+"""
+if (openclosed not in ["open", "closed", "all",]) :
+raise ValueError( "Invalid value for openclosed parameter: %s" % openclosed )
+if (openclosed == "open") :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()
+if (not self.repo[head[0]].extra().get( "close", False ) )]
+elif (openclosed == "closed") :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()
+if (self.repo[head[0]].extra().get( "close", False ))]
+else :
+all_branches = [Branch( self.ui, self.repo, head[0] ) for branch_fullname, head in self.repo.branchmap().items()]
+return all_branches
+def _find_branch( self, fullname ) :
+"""
+Return true if a branch C{fullname} is open.
+@type  fullname: C{str}
+@param fullname: Fullname of branch that you want to know whether it is open
+"""
+try :
+Branch( self.ui, self.repo, fullname )
+return True
+except error.RepoLookupError :
+return False
+def latest_master_tags( self ) :
+"""
+Return the latest tag of C{<master>} branch.
+"""
+trunk          = STREAM["master"].trunk()
+trunk_fullname = trunk.fullname()
+master_context = trunk.ctx
+while (master_context) :
+tags = master_context.tags()
+try :
+tags.remove( "tip" )
+except ValueError :
+pass
+if (tags) :
+return tags
+parents        = master_context.parents()
+master_context = None
+for e in parents :
+if (trunk_fullname == e.branch()) :
+master_context = e
+break
+return []
+def _create_branch( self, fullname, message, from_branch = None, **kwarg ) :
+"""
+Create a new branch and commit the change.
+@type     fullname: C{str}
+@param    fullname: Fullname of the new branch
+@type      message: C{str}
+@param     message: Commit message
+@type  from_branch: C{Branch}
+@param from_branch: Parent branch of the new branch
+"""
+if (from_branch and self.curr_workspace != from_branch) :
+self._update( from_branch )
+self._branch( fullname )
+self._commit( message = message, **kwarg )
+if (commands.dryrun()) :
+# Makes a fake new branch.
+self.curr_workspace = Branch( self.ui, self.repo )
+self.curr_workspace._fullname = fullname
+else :
+self.curr_workspace = Branch( self.ui, self.repo, fullname )
+def _action_start( self, stream, *arg, **kwarg ) :
+"""
+Conduct the I{start} action for the given stream. A new branch in the stream will be created.
+@type  stream: C{Stream}
+@param stream: Stream where you want to start a new branch
+"""
+try :
+basename = arg[1]
+except IndexError :
+raise AbortFlow( "You must specify a name for the new branch to start." )
+rev      = kwarg.pop( "rev",     None )
+msg      = kwarg.pop( "message", ""   )
+dirty    = kwarg.pop( "dirty",   None )
+fullname = stream.get_fullname( basename )
+if (self._find_branch( fullname )) :
+self._warn( "An open branch named '%s' already exists in %s." % (basename, stream,) )
+else :
+shelvedpatch_basename = self.curr_workspace.fullname()
+if (rev is None) :
+from_branch = stream.source().trunk()
+self._shelve( force = dirty )
+self._update( from_branch )
+else :
+from_branch = Branch( self.ui, self.repo, rev )
+if (from_branch._fullname != stream.source()._trunk) :
+raise AbortFlow( "Revision %s is not in the source stream of %s." % (rev, stream,) )
+self._shelve( force = dirty )
+self._update( rev = rev )
+if (msg) :
+msg = "%s\n" % msg
+self._create_branch( fullname, "%s%sCreated branch '%s'." % (msg, self.msg_prefix, fullname,), **kwarg )
+if (dirty) :
+self._unshelve( shelvedpatch_basename, force = dirty )
+def _action_push( self, stream, *arg, **kwarg ) :
+"""
+Conduct the I{push} action for the given stream. The workspace branch will be pushed to the remote repository.
+@type  stream: C{Stream}
+@param stream: Stream where you want to push the workspace branch
+"""
+if (self.curr_workspace in stream) :
+self._push( new_branch = True, branch = [self.curr_workspace.fullname(),] )
+else :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (self.curr_workspace, stream,),
+"To push a %s branch, you must first update to it." % stream )
+def _action_pull( self, stream, *arg, **kwarg ) :
+"""
+Conduct the I{pull} action for the given stream. The workspace branch will be updated with changes pulled from the
+remote repository.
+@type  stream: C{Stream}
+@param stream: Stream where you want to pull for the workspace branch
+"""
+try :
+branch = stream.get_fullname( arg[1] )
+except IndexError :
+branch = self.curr_workspace
+if (branch not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (branch, stream,),
+"To pull a %s branch, you must first update to it." % stream )
+self._pull( update = True, branch = [branch,] )
+def _action_list( self, stream, *arg, **kwarg ) :
+"""
+Print all open branches in the given stream.
+@type  stream: C{Stream}
+@param stream: Stream of which you want to display open branches
+"""
+# Lists all open branches in this stream.
+open_branches = stream.branches()
+trunk         = stream.trunk()
+if (trunk) :
+tags = ""
+if (stream == STREAM["master"]) :
+tags = self.latest_master_tags()
+tags = (", latest tags: %s" % ", ".join( tags )) if (tags) else ""
+self._print( "%s trunk: %s%s" % (stream, trunk, tags,) )
+if (open_branches) :
+self._print( "Open %s branches:" % stream )
+for e in open_branches :
+marker  = "#" if (self._is_shelved( e )  ) else ""
+marker += "*" if (e == self.curr_workspace) else ""
+self._print( str( e ) + marker, prefix = "  " )
+else :
+self._print( "No open %s branches" % stream )
+if (kwarg.get( "closed" )) :
+closed_branches = stream.branches( "closed" )
+if (closed_branches) :
+self._print( "Closed %s branches:" % stream )
+closed_branches.sort( lambda x, y : y.ctx.rev() - x.ctx.rev() )
+for e in closed_branches :
+self.ui.write( "%-31s"   % e.basename( stream ),                  label = "branches.closed" )
+self.ui.write( " %5s:%s" % (e.ctx.rev(), short( e.ctx.node() ),), label = "log.changeset"   )
+self.ui.write( "  %s\n"  % util.datestr( e.ctx.date(), format = "%Y-%m-%d %a %H:%M %1" ),
+label = "log.date" )
+bn = str( e )
+p1 = e.ctx
+while (p1.branch() == bn) :
+e  = p1
+p1 = e.p1()
+description = e.description()
+msg_prefix  = ("flow: ", "hgflow: ", "hg flow,", self.msg_prefix or "#@$(&*^$",)
+if (not (description.startswith( msg_prefix ))) :
+lines = [e.strip() for e in description.split( "\n" )]
+self.ui.note( "  description: %s\n" % lines[0] )
+for line in lines[1:] :
+if (not (line.startswith( msg_prefix ))) :
+self.ui.note( "               %s\n" % lines[0] )
+self.ui.note( "\n" )
+else :
+self._print( "No closed %s branches" % stream )
+def _action_log( self, stream, *arg, **kwarg ) :
+"""
+Show revision history of the specified branch.
+@type  stream: C{Stream},
+@param stream: Stream where the specified branch is
+"""
+# User may specify a file with a relative path name. Since CWD has changed to the repository's root dir when the
+# `Flow' object was constructed, we need to restore the original dir to get the correct path name of the file.
+os.chdir( self.orig_dir )
+filenames = kwarg.pop( "file", [] )
+onstream  = kwarg.pop( "onstream", False )
+closed    = kwarg.pop( "closed",   False )
+if (onstream) :
+filenames.extend( arg[1:] )
+branches = stream.branches( "all" if (closed) else "open" )
+if (stream._trunk) :
+branches.append( stream._trunk )
+else :
+# Case 1: hg flow <stream> log <basename>
+#         - Shows the log of the "<stream>/<basename>" branch.
+# Case 2: hg flow <stream> log
+#         - Case 2a: <stream> does not have a trunk
+#                    - Shows the log of the current workspace, which should be a branch in <stream>.
+#         - Case 2b: <stream> has a trunk
+#                    - Case 2b1: Current workspace is a branch in <stream>.
+#                                - Shows the log of the current workspace.
+#                    - Case 2b2: Current workspace is not a branch in <stream>.
+#                                - Shows the log of <stream>'s trunk.
+# Case 3: hg flow <stream> log <filename>
+#         - This case can be overriden by Case 1. Namely, if the <filename> happens to be the same as the
+#           <basename>, the latter will take precedence.
+#         - Case 3a: The current workspace is in <stream>
+#                    - Show the log of <filename> in the current workspace branch.
+#         - Case 3b: The current workspace is not in <stream>, and <stream> has a trunk.
+#                    - Show the log of <filename> in <stream>'s trunk.
+#         - Case 3c: The current workspace is not in <stream>, and <stream> has no trunk.
+#                    - Error
+try :
+branch = stream.get_branch( arg[1] )
+# Case 1
+except error.RepoLookupError :
+filenames.append( arg[1] )
+if (self.curr_workspace in stream) :
+# Case 3a
+branch = self.curr_workspace
+else :
+branch = stream.trunk()
+if (not branch) :
+# Case 3c
+raise AbortFlow( "Cannot determine branch in %s. Please be more specific." % stream )
+else :
+# Case 3b
+# Just be clear that we have covered Case 2b2.
+pass
+except IndexError :
+branch = stream.trunk()
+if (not branch) :
+# Case 2a
+branch = self.curr_workspace
+if (branch not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (branch, stream,),
+"To show log of a %s branch, you must also specify its name." % stream )
+elif (self.curr_workspace in stream) :
+# Case 2b1
+branch = self.curr_workspace
+else :
+# Case 2b2
+# Just be clear that we have covered Case 2b2.
+pass
+# At this point, `branch` must be existent.
+branches = [branch,]
+# OK. We have to explicitly specify the date, rev, and user arguments to prevent mercurial python APIs from crashing.
+opts = {"date" : None, "rev" : None, "user" : None, "branch" : branches,}
+opts.update( kwarg )
+self._log( *filenames, **opts )
+def _action_abort( self, stream, *arg, **kwarg ) :
+"""
+Abort the workspace branch.
+@type  stream: C{Stream}
+@param stream: Stream where the branch which you want to abort is
+"""
+msg            = kwarg.pop( "message",  ""    )
+should_erase   = kwarg.pop( "erase",    False )
+onstream       = kwarg.pop( "onstream", False )
+curr_workspace = self.curr_workspace
+if (msg) :
+msg = "%s\n" % msg
+if (curr_workspace.is_develop_trunk()) :
+raise AbortFlow( "You cannot abort the <develop> trunk." )
+if (onstream) :
+branches = stream.branches()
+if (stream == STREAM["develop"]) :
+branches.remove( stream.trunk() )
+elif (stream._trunk) :
+branches.append( stream.trunk() )
+for branch in branches :
+if (should_erase) :
+self._strip( rev = ["branch('%s')" % branch,] )
+else :
+self._update( branch )
+self._commit( close_branch = True, message = "%s%sAborted %s %s." %
+(msg, self.msg_prefix, stream, branch.basename( stream, should_quote = True ),) )
+if (self.curr_workspace != self.orig_workspace and self._orig_workspace not in branches) :
+self._update( self.orig_workspace )
+else :
+if (curr_workspace.is_trunk( stream )) :
+curr_stream = curr_workspace.stream()
+raise AbortFlow( "You cannot abort a trunk.",
+"To abort '%s' as a branch, use `hg flow %s abort`." % (curr_workspace, curr_stream.name(),)
+)
+if (curr_workspace not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (curr_workspace, stream,),
+"To abort a %s branch, you must first update to it." % stream )
+if (should_erase) :
+self._strip( rev = ["branch('%s')" % curr_workspace,] )
+else :
+self._commit( close_branch = True, message = "%s%sAborted %s '%s'." %
+(msg, self.msg_prefix, stream, curr_workspace.basename( stream ),) )
+self._update( stream.trunk( trace = True ) )
+self._unshelve()
+def _action_promote( self, stream, *arg, **kwarg ) :
+"""
+Promote the workspace branch to its destination stream(s). If there are uncommitted changes in the current branch,
+they will be automatically shelved before rebasing and unshelved afterwards.
+@type  stream: C{Stream}
+@param stream: Stream where the branch which you want to rebase is
+@type     rev: C{str}
+@param    rev: If provided, promote this revision instead of the head. The specified revision must be in the workspace
+branch.
+"""
+rev            = kwarg.pop( "rev",     None )
+tag_name       = kwarg.pop( "tag",     None )
+message        = kwarg.pop( "message", None )
+message        = (message + "\n") if (message) else ""
+orig_workspace = self.curr_workspace
+has_shelved    = False
+if (orig_workspace not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (orig_workspace, stream,),
+"To promote a %s branch, you must first update to it." % stream )
+if (rev) :
+# Ensures `rev` is in workspace branch.
+promoted_branch = Branch( self.ui, self.repo, rev )
+promoted_rev    = rev
+promoted_node   = promoted_branch.ctx.node()
+if (promoted_branch != orig_workspace) :
+raise AbortFlow( "Revision %s is not in workspace branch." % rev )
+else :
+promoted_branch = orig_workspace
+promoted_rev    = orig_workspace
+promoted_ctx    = promoted_branch.ctx
+promoted_node   = promoted_ctx.node()
+# `promoted_node' is `None' if the `promote_ctx' is an instance of `workingctx'.
+while (promoted_node is None) :
+promoted_ctx  = promoted_ctx._parents[0]
+promoted_node = promoted_ctx.node()
+if (arg[1:]) :
+if (not has_shelved) :
+self._shelve()
+has_shelved = True
+for dest in arg[1:] :
+self._update( dest          )
+self._merge ( promoted_rev  )
+self._commit( message = message + ("%sPromoted %s '%s' (%s) to '%s'." %
+(self.msg_prefix, stream, promoted_branch.basename( stream ),
+short( promoted_node ), dest,)), **kwarg )
+if (tag_name) :
+self._tag( tag_name, **kwarg )
+else :
+destin = [STREAM["master"],] if (STREAM["develop"] == stream) else stream.destin()
+for s in destin :
+if (s == stream) :
+continue
+trunk = s.trunk()
+if (trunk) :
+if (not has_shelved) :
+self._shelve()
+has_shelved = True
+self._update( trunk        )
+self._merge ( promoted_rev )
+self._commit( message = message + ("%sPromoted %s '%s' (%s) to '%s'." %
+(self.msg_prefix, stream, promoted_branch.basename( stream ),
+short( promoted_node ), trunk,)), **kwarg )
+if (tag_name) :
+self._tag( tag_name, **kwarg )
+else :
+self._error( "Cannot determine promote destination." )
+return
+if (orig_workspace != self.curr_workspace) :
+self._update( orig_workspace )
+self._unshelve()
+def _action_rebase( self, stream, *arg, **kwarg ) :
+"""
+Rebase the workspace branch to its parent branch. If there are uncommitted changes in the current branch, they will be
+automatically shelved before rebasing and unshelved afterwards.
+@type  stream: C{Stream}
+@param stream: Stream where the branch which you want to rebase is
+@type  dest:   C{str}
+@param dest:   If provided, use its value as the destination of rebasing. The value must be a changeset of the parent
+branch, otherwise it will trigger an error. If not provided, use the tip of the parent branch as the
+destination of rebasing.
+"""
+dest     = kwarg.get( "dest" )
+onstream = kwarg.pop( "onstream", False )
+if (onstream) :
+if (not dest) :
+dest = stream.source().trunk( trace = True )
+branches = stream.branches()
+if (stream == STREAM["develop"]) :
+branches.remove( stream.trunk() )
+elif (stream._trunk) :
+branches.append( stream.trunk() )
+self._check_rebase()
+self._shelve()
+for branch in branches :
+if (dest != branch) :
+self._rebase( base = branch, dest = dest, keepbranches = True )
+self._unshelve()
+else :
+curr_workspace = self.curr_workspace
+if (not dest) :
+dest = stream.trunk( trace = True )
+if (curr_workspace not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (curr_workspace, stream,),
+"To rebase a %s branch, you must first update to it." % stream )
+if (curr_workspace.is_develop_trunk()) :
+raise AbortFlow( "You cannot rebase the <develop> trunk." )
+if (dest == curr_workspace) :
+self._warn( "No effects from rebasing a branch to itself" )
+else :
+self._check_rebase()
+self._shelve()
+self._rebase( base = curr_workspace, dest = dest, keepbranches = True )
+self._unshelve()
+def _update_workspace( self, stream, branch, verbose = True ) :
+"""
+Update the workspace to the given branch. Shelving and unshelving will be conducted automatically.
+@type  stream: C{Stream}
+@param stream: Stream where the branch which you are updating the workspace to is
+@type  branch: C{Branch} or C{None}
+@param branch: Branch to update the workspace to. No effects if it is C{None}.
+"""
+if (not branch) :
+return
+if (branch == self.curr_workspace) :
+if (verbose) :
+self._print( "You are already in %s %s." % (stream, branch.basename( stream, should_quote = True ),) )
+else :
+self._print( "Update workspace to %s %s." % (stream, branch.basename( stream, should_quote = True ),) )
+self._shelve()
+self._update( branch )
+self._unshelve()
+def _action_other( self, stream, *arg, **kwarg ) :
+"""
+If the action is the name of a branch in the given stream, we will update workspace to that branch; otherwise, the
+action is considered as an error.
+@type  stream: C{Stream}
+@param stream: Stream where the branch that we will switch to is
+"""
+try :
+name   = arg[0]
+branch = stream.get_branch( name )
+if (branch.is_closed()) :
+self._warn( "%s '%s' has been closed." % (stream, name,) )
+self._update_workspace( stream, branch )
+except error.RepoLookupError :
+misspelling = difflib.get_close_matches( name, ["start", "finish", "push", "publish", "pull",
+"list", "log", "abort", "promote", "rebase",], 3, 0.7 )
+note = ("Did you mean: %s?" % " or ".join( misspelling )) if (misspelling    ) else None
+note = ("Did you mean: finish or abort?")                 if ("close" == name) else note
+note = ("If you meant to create a new branch called '%s' in %s" % (name, stream,),
+"try command:", "  hg flow %s start %s" % (stream.name(), name,),) if (not note) else note
+raise AbortFlow( "Invalid action or unknown branch in %s: '%s'" % (stream, name,), note = note )
+def _commit_change( self, opt, commit_hint, is_erasing = False ) :
+"""
+Commit the changes in the workspace.
+Note that this method can potentially mutate C{opt}. Specifically, it will delete the C{commit} and C{message} keys if
+they present in C{opt}.
+@type  opt: C{dict}
+@param opt: Option dictionary. Recognizable keys are C{commit} and C{message}. The value of C{commit} should be a
+boolean, indicating whether or not to perform committing. The value of C{message} should be a string, which
+will be used as the commit message. It is OK for both of the options to be missing. But it would trigger
+an error if C{message} is given without C{commit} set to true. There is no special treatment on other
+keys, and they will be passed to the C{hg commit} command as is.
+@rtype : C{bool}
+@return: Return `True' if committing was successfully done, or `False' if it was not.
+"""
+if (opt.get( "commit" )) :
+del opt["commit"]
+msg = opt.get( "message" )
+if (msg is None) :
+opt["force_editor"] = True
+opt["message"] = "\n\nHG: flow: %s" % commit_hint
+self._commit( **opt )
+del opt["message"]
+if (msg is None) :
+del opt["force_editor"]
+return True
+elif (opt.get( "message" )) :
+if (is_erasing) :
+del opt["message"]
+else :
+raise AbortFlow( "Cannot use the specified commit message.", "Did you forget to specify the -c option?" )
+return False
+def _action_finish( self, stream, *arg, **kwarg ) :
+"""
+Finish a branch in the given stream. The current workspace must be in the branch to be finished, otherwise an error
+will be triggered. The default behavior of finish action is the following:
+1. close the branch.
+2. merge the branch to the C{destin} streams.
+@type  stream: C{Stream}
+@param stream: Stream where the branch that we will finish is
+"""
+try :
+tag_name = arg[1]
+self._warn( "You just specified the <tag-name> using the deprecated syntax:" )
+self._warn( "  hg flow <stream> finish <tag-name> [<options>]" )
+self._warn( "Try using the new syntax to do that in the future: hg flow <stream> finish -t <tag-name>" )
+self._warn( "Note that hgflow intentionally forbids finishing a non-workspace branch." )
+except IndexError :
+tag_name = None
+message        = kwarg.get( "message",  None  )
+tag_name       = kwarg.pop( "tag",      tag_name )
+onstream       = kwarg.pop( "onstream", False )
+should_erase   = kwarg.pop( "erase",    False )
+curr_workspace = self.curr_workspace
+curr_stream    = curr_workspace.stream()
+name           = curr_workspace.basename( stream, should_quote = True )
+tag_name       = tag_name if (tag_name) else (self.version_prefix + name[1:-1])
+develop_stream = STREAM["develop"]
+if (should_erase) :
+if (onstream       ) : raise AbortFlow( "'--erase' cannot be used together with '--onstream'." )
+if (message is None) : raise AbortFlow( "'--message' is required when '--erase' is used." )
+self._check_strip()
+if (onstream) :
+if (stream in [develop_stream, STREAM["support"], STREAM["hotfix"], STREAM["release"],]) :
+raise AbortFlow( "You cannot finish %s." % stream )
+branches = stream.branches()
+if (stream._trunk) :
+substream = Stream.gen( self.ui, self.repo, stream.name() )
+for branch in branches :
+self._update( branch )
+self._action_finish( substream, *arg, **kwarg )
+self._update( stream.trunk() )
+self._action_finish( stream, *arg, **kwarg )
+else :
+for branch in branches :
+self._update( branch )
+self._action_finish( stream, *arg, **kwarg )
+return
+if (curr_workspace.is_develop_trunk()) :
+raise AbortFlow( "You cannot finish the <develop> trunk." )
+elif (curr_workspace not in stream) :
+raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (curr_workspace, stream,),
+"To finish a %s branch, you must first update to it." % stream )
+# Merges the workspace to its `destin` streams.
+destin_with_trunk    = []
+destin_without_trunk = []
+final_branch         = None
+for s in stream.destin() :
+trunk = s.trunk()
+if (trunk == curr_workspace) :
+pass
+elif (trunk) :
+destin_with_trunk.append( s )
+else :
+destin_without_trunk.append( s )
+if (should_erase) :
+if (len( destin_with_trunk + destin_without_trunk ) > 1) :
+raise AbortFlow( "'--erase' cannot be applied to branches with multiple merge destinations." )
+# Commits changes (if any) in the current branch.
+is_commit_done = self._commit_change( kwarg, "Finishing '%s' branch" % curr_workspace, should_erase )
+# If the commit was done successfully, we don't check against uncommitted changes.
+# This is particularly needed for dry run.
+if (not is_commit_done and self._has_uncommitted_changes()) :
+raise AbortFlow( "Cannot finish '%s' branch because it has uncommitted changes." % curr_workspace )
+# For destin streams without trunks, we need to create a branch in each of these destin streams.
+# Each newly created branch will be named after the pattern: <stream-prefix>/<current-branch-basename> and will be from
+# the current branch. The current branch will be closed. Note that there is no need to merge the current branch because
+# a new branch has been created from it.
+for s in destin_without_trunk :
+trunk    = s.trunk()
+so_name  = "" if ("trunk" == curr_workspace.basename( stream )) else ("/" + curr_workspace.basename( stream ))
+so       = Stream( self.ui, self.repo, stream.name() + so_name, trunk = curr_workspace.fullname() )
+so       = "%s:%s" % (so.name(), s.name(),)
+basename = curr_workspace.basename()
+self.action( so, "start", basename )
+final_branch = s.get_fullname( basename )
+if (destin_with_trunk or destin_without_trunk) :
+# If either list is not empty.
+self._update( curr_workspace )
+self._commit( close_branch = True, message = "%sClosed %s %s." % (self.msg_prefix, stream, name,), **kwarg )
+else :
+# If both lists are empty.
+if (stream == STREAM["support"]) :
+self._update( curr_workspace )
+self._commit( close_branch = True, message = "%sClosed %s %s." % (self.msg_prefix, stream, name,), **kwarg )
+final_branch = STREAM["master"].trunk()
+else :
+self._print( "All open branches in %s are finished and merged to its trunk." % stream )
+for s in destin_with_trunk :
+trunk = s.trunk()
+self._update( trunk          )
+self._merge ( curr_workspace )
+self._commit( message = "%sMerged %s %s to %s ('%s')." % (self.msg_prefix, stream, name, s, trunk,), **kwarg )
+if (s == STREAM["master"]) :
+self._tag( tag_name )
+elif (s in develop_stream and s is not develop_stream) :
+tr_stream = trunk.stream()
+for ss in tr_stream.destin() :
+if (ss == develop_stream) :
+dvtrunk = develop_stream.trunk()
+tr_name = trunk.basename( ss )
+self._update( dvtrunk )
+self._merge ( trunk   )
+self._commit( message = "%sMerged <develop/%s:%s> %s to %s ('%s')." %
+(self.msg_prefix, tr_name, stream.name(), name, ss, dvtrunk,), **kwarg )
+if (final_branch) :
+self._update( final_branch )
+if (should_erase) :
+rev = "p1(.)"
+rev = mercurial.scmutil.revsingle( self.repo, rev ).rev()
+self._update( "tip" )
+self._update( rev   )
+self._revert( rev = "-1", all = True )
+self._strip ( rev = ["branch('%s')" % curr_workspace,] )
+self._commit( message = message, **kwarg )
+self._unshelve()
+def _execute_action( self, stream, *arg, **kwarg ) :
+"""
+Execute an action on the given stream. If no action is specified, the action will default to I{list}
+(see L{_action_list}). The default behavior of an action is defined by the C{_action_*} methods. Custom action behavior
+can be given through the C{action_func} parameter.
+@type  stream:      C{Stream}
+@param stream:      Stream where we will execute the action
+@type  action_func: C{dict}
+@param action_func: Custom action methods. Key (C{str}) is action name, and value is a function that define the
+behavior of the custom action.
+"""
+try :
+action = arg[0]
+except IndexError :
+action = "list"
+action_func = {
+"start"   : self._action_start,
+"finish"  : self._action_finish,
+"push"    : self._action_push,
+"publish" : self._action_push,
+"pull"    : self._action_pull,
+"list"    : self._action_list,
+"log"     : self._action_log,
+"abort"   : self._action_abort,
+"promote" : self._action_promote,
+"rebase"  : self._action_rebase,
+"other"   : self._action_other,
+}
+custom_action_func = kwarg.pop( "action_func", {} )
+action_func.update( custom_action_func )
+return action_func.get( action, self._action_other )( stream, *arg, **kwarg )
+def action( self, stream, *arg, **kwarg ) :
+"""
+Execute action on the stream.
+"""
+if (len( arg ) > 0) :
+action = arg[0]
+if (stream == STREAM["master"]) :
+if (action in ["start", "finish", "abort", "rebase",]) :
+raise AbortFlow( "Invalid action for <master>" )
+else :
+self._update_workspace( stream, stream.trunk(), verbose = False )
+self._execute_action( stream, *arg, **kwarg )
+def print_version( self, *arg, **kwarg ) :
+"""
+Print flow's version and then quit.
+"""
+self._print( "version %s" % VERSION )
+def unshelve( self, *arg, **kwarg ) :
+"""
+Unshelve the previously shelved changes.
+"""
+self.autoshelve = True
+self._unshelve( *arg, **kwarg )
+def print_open_branches( self, *arg, **kwarg ) :
+"""
+Print open branches in each stream.
+The currently active branch will be marked with a * symbol. Branches where there are shelved changes will be marked
+with a # symbol.
+"""
+self._print( "Currently open branches:" )
+curr_workspace = self.curr_workspace
+stream_names   = ["master", "develop", "feature", "release", "hotfix", "support",]
+all_branches   = self._branches()
+for sn in stream_names :
+stream = STREAM[sn]
+trunk  = stream.trunk()
+open_branches_in_stream = []
+remaining_branches      = []
+for e in all_branches :
+if (e in stream) :
+open_branches_in_stream.append( e )
+else :
+remaining_branches.append( e )
+all_branches = remaining_branches
+if (trunk is None and not open_branches_in_stream) :
+continue
+self._print( "%-9s: " % stream, newline = False )
+if (trunk) :
+marker  = "#" if (self._is_shelved( trunk )) else ""
+marker += "*" if (trunk == curr_workspace  ) else ""
+self.ui.write( "%s%s " % (trunk, marker,) )
+if (trunk in open_branches_in_stream) :
+# We need this check because the `trunk' could be closed. See Issue#34.
+open_branches_in_stream.remove( trunk )
+if (open_branches_in_stream) :
+for e in open_branches_in_stream :
+marker  = "#" if (self._is_shelved( e )) else ""
+marker += "*" if (e == curr_workspace  ) else ""
+self.ui.write( "%s%s " % (e, marker,) )
+self.ui.write( "\n" )
+def init( self, *arg, **kwarg ) :
+"""
+Initialize flow.
+"""
+config_fname   = os.path.join( self.repo.root, CONFIG_BASENAME )
+master_stream  = "default"
+hotfix_stream  = "hotfix/"
+develop_stream = "develop"
+feature_stream = "feature/"
+release_stream = "release/"
+support_stream = "support/"
+has_goodconfig = False
+# Fetches existing condition
+if (os.path.isfile( config_fname )) :
+self._print( "Flow was already initialized for workspace:" )
+cfg = config.config()
+cfg.read( config_fname )
+SECTION = CONFIG_SECTION_BRANCHNAME
+try :
+master_stream  = cfg.get( SECTION, "master"  )
+develop_stream = cfg.get( SECTION, "develop" )
+feature_stream = cfg.get( SECTION, "feature" )
+release_stream = cfg.get( SECTION, "release" )
+hotfix_stream  = cfg.get( SECTION, "hotfix"  )
+support_stream = cfg.get( SECTION, "support" )
+has_goodconfig = True
+except ConfigParser.NoSectionError :
+self._error( "Section [%s] not found in configuration file: %s" % (SECTION, config_fname,) )
+self._error( "Your configuration file is probably in old format or corrupt." )
+except ConfigParser.NoOptionError, e :
+self._error( "%s" % e )
+self._error( "Your configuration file is probably corrupt." )
+if (has_goodconfig) :
+self._print( "Repository-specific configuration:" )
+self._print( "<master>  trunk: '%s'"         %  master_stream, prefix = "  " )
+self._print( "<develop> trunk: '%s'"         % develop_stream, prefix = "  " )
+self._print( "<feature> branch prefix: '%s'" % feature_stream, prefix = "  " )
+self._print( "<release> branch prefix: '%s'" % release_stream, prefix = "  " )
+self._print( "<hotfix>  branch prefix: '%s'" %  hotfix_stream, prefix = "  " )
+self._print( "<support> branch prefix: '%s'" % support_stream, prefix = "  " )
+autoshelve = None
+if (self.ui.has_section( "hgflow" ) or self.ui.has_section( "flow" )) :
+self._print( "Global configuration:" )
+autoshelve = self.ui.configbool( "hgflow", "autoshelve" )
+if (self.ui.has_section( "flow" )) :
+autoshelve = self.ui.configbool( "flow", "autoshelve" )
+if (not (autoshelve is None)) :
+self._print( "autoshelve: %s" % ("on" if (autoshelve) else "off"), prefix = "  " )
+# Shall we continue if there already exists a configuration file?
+if (has_goodconfig and not kwarg.get( "force" )) :
+return
+print
+mq = None
+try :
+mq = extensions.find( "mq" )
+except KeyError :
+self._warn( "The 'mq' extension is deactivated. You cannot use some features of flow." )
+print
+workspace = self.curr_workspace
+branches  = self._branches()
+if (len( branches ) > 1) :
+self._warn( "You have the following open branches. Will initialize flow for all of them." )
+for branch in branches :
+if (branch == workspace) :
+self._warn( "  " + branch.fullname() + " (active)" )
+else :
+self._warn( "  %s" % branch.fullname() )
+print
+# 'status' method returns a 7-member tuple:
+# 0 modified, 1 added, 2 removed, 3 deleted, 4 unknown(?), 5 ignored, and 6 clean
+orig_repo_status = self.repo.status()[:4]
+for e in orig_repo_status :
+try :
+e.remove( CONFIG_BASENAME )
+except ValueError :
+pass
+if (any( orig_repo_status )) :
+if (len( branches ) > 1 and not mq) :
+raise AbortFlow( "Your workspace has uncommitted changes. Cannot initialize flow for all",
+"  open branches. You can either commit the changes or install the 'mq'",
+"  extension, and then try again." )
+def get_input( stream_name, default ) :
+while (True) :
+answer = self.ui.prompt( "Branch name for %s stream: [%s]" % (stream_name, default,), default = default )
+if (answer.find( ':' ) > -1) :
+self._error( "Illegal symbol ':' in branch name" )
+else :
+return answer
+if (not kwarg.get( "default" )) :
+master_stream  = get_input( "master",   master_stream )
+develop_stream = get_input( "develop", develop_stream )
+feature_stream = get_input( "feature", feature_stream )
+release_stream = get_input( "release", release_stream )
+hotfix_stream  = get_input( "hotfix",   hotfix_stream )
+support_stream = get_input( "support", support_stream )
+if (autoshelve is None) :
+self._print( """
+When you switch to another branch, flow can automatically shelve uncommitted
+changes in workpace right before switching. Later when you switch back, flow can
+automatically unshelve the changes to the workspace. This functionality is
+called autoshelve. You need the 'mq' extension to use it.""" )
+answer = self.ui.prompt( "Do you want to turn it on? [Yes] ", default = "y" )
+answer = True if (answer.lower() in ["yes", "y", "",]) else False
+if (answer) :
+self._print( """
+Here is what you need to do:
+To turn it on for only this repository, edit your <repository-root>/.hg/hgrc
+file by adding the following lines:
+[flow]
+autoshelve = true
+You can turn it on for all of your repositories by doing the same edition to
+your $HOME/.hgrc file. To turn it off, just edit the corresponding file and
+replace 'true' with 'false'.
+""" )
+self.ui.prompt( _("Press Enter to continue initialization...") )
+# Creates configuration.
+cfg_contents = ["[%s]" % CONFIG_SECTION_BRANCHNAME,
+"master  = %s" %  master_stream,
+"develop = %s" % develop_stream,
+"feature = %s" % feature_stream,
+"release = %s" % release_stream,
+"hotfix  = %s" %  hotfix_stream,
+"support = %s" % support_stream,]
+def write_config() :
+# Writes the configuration in the current branch.
+with open( config_fname, "w" ) as fh :
+print >> fh, "\n".join( cfg_contents )
+repo_status = self.repo.status( unknown = True )
+if (CONFIG_BASENAME in repo_status[0]) :
+self._commit( config_fname, message = "flow initialization: Modified configuration file." )
+elif (CONFIG_BASENAME in repo_status[4]) :
+self._add   ( config_fname )
+self._commit( config_fname, message = "flow initialization: Added configuration file." )
+write_config()
+# Writes the configuration in all the other branches.
+self.autoshelve = True
+self._shelve()
+if (len( branches ) > 1) :
+for branch in branches :
+if (branch == workspace) : continue
+self._update( branch )
+write_config()
+self._update( workspace )
+# Creates 'master' and 'develop' streams if they don't yet exist.
+if (not self._find_branch( master_stream )) :
+self._create_branch( master_stream, "flow initialization: Created <master> trunk: %s." % master_stream )
+if (not self._find_branch( develop_stream )) :
+self._create_branch( develop_stream, "flow initialization: Created <develop> trunk: %s." % develop_stream )
+self._update( workspace )
+self._unshelve()
+def upgrade( self, *arg, **kwarg ) :
+"""
+Upgrade older version to the latest version.
+"""
+self._print( "Upgrade flow's configuration file from v0.9.4 (or older) to v0.9.5 (or latter)." )
+self._print( "Renaming file '%s' to '%s' in all open branches..." % (OLD_CONFIG_BASENAME, CONFIG_BASENAME,) )
+config_fname     = os.path.join( self.repo.root,     CONFIG_BASENAME )
+old_config_fname = os.path.join( self.repo.root, OLD_CONFIG_BASENAME )
+workspace = self.curr_workspace
+for branch in self._branches() :
+self._print( "  Branch '%s'..." % branch )
+self._update( branch )
+if (os.path.isfile( old_config_fname )) :
+self._rename( old_config_fname, config_fname, force = True )
+self._commit( message = "flow upgrade: Renamed flow's configuration file from '%s' to '%s'." %
+(OLD_CONFIG_BASENAME, CONFIG_BASENAME,) )
+self._update( workspace )
+self._print( "Upgrading done" )
+def flow_cmd( ui, repo, cmd = None, *arg, **kwarg ) :
+"""Flow is a Mercurial extension to support the generalized Driessen's branching model.
+actions:
+- start    Open a new branch in the stream.
+- finish   Close workspace branch and merge it to destination stream(s).
+- push     Push workspace branch to the remote repository.
+- publish  Same as `push`
+- pull     Pull from the remote repository and update workspace branch.
+- list     List all open branches in the stream.
+- log      Show revision history of branch.
+- promote  Merge workspace to other branches. (not closing any branches.)
+- rebase   Rebase workspace branch to its parent branch.
+- abort    Abort branch. Close branch without merging.
+If no action is specified by user, the action will default to `list`. If a
+branch name (instead of action) is given after the stream name, Flow will
+switch the current workspace to the branch.
+commands:
+- init     Initialize flow.
+- unshelve Unshelve the previously shelved changes for workspace branch.
+- upgrade  Upgrade the configuration file to v0.9.5 or later.
+- help     Show help for a specific topic. Example: `hg flow help @help`
+- version  Show flow's version number.
+"""
+# Supresses bookmarks, otherwise if the name of a bookmark happens to be the same as a named branch, hg will use the
+# bookmark's revision.
+repo._bookmarks = {}
+flow = Flow( ui, repo, cmd in ["init", "upgrade", "help",] )
+func = {
+"init"     : flow.init,
+"upgrade"  : flow.upgrade,
+"unshelve" : flow.unshelve,
+"help"     : Help( ui, repo ).print_help,
+"version"  : flow.print_version,
+None       : flow.print_open_branches,
+}
+commands.use_quiet_channel( kwarg.get( "history" ) )
+commands.dryrun           ( kwarg.get( "dry_run" ) )
+if (kwarg.get( "dry_run" )) :
+_print( ui, "This is a dry run." )
+commands.use_quiet_channel( True )
+# Registers common options (such as "user").
+common_opts = {}
+for e in ["user",] :
+v = kwarg.get( e )
+if (v) :
+common_opts[e] = v
+commands.reg_common_options( common_opts )
+# - Up to this point, `cmd' is a name of command or stream, or `None'.
+# - We assign `stream' to be a stream name (or `None') and `cmd' to be a name of command or action.
+# - When `arg' is a 0-tuple, `cmd' should be "list" as the default action. We use `arg + ("list",)' to ensure we can get
+#   the first element.
+stream, cmd = (None, cmd) if (cmd in func) else (cmd, (arg + ("list",))[0] )
+try :
+# Constructs a `Stream' objects.
+# This will also check the validity of the part of user's input that is supposed to specify a stream.
+if (isinstance( stream, str )) :
+source = None
+tokens = stream.split( ':' )
+n      = len( tokens )
+if (n == 2) :
+source, stream = tokens[0], tokens[1]
+if (n > 2 or not stream) :
+raise AbortFlow( "Invalid stream syntax: '%s'" % stream )
+try :
+stream = Stream.gen( ui, repo, stream, check = True )
+except AbnormalStream, e :
+stream = e.stream()
+if (source) :
+try :
+source = Stream.gen( ui, repo, source, check = True )
+except AbnormalStream, e :
+source = e.stream()
+stream = copy.copy( stream )
+stream._source = source
+for i, e in enumerate( stream.destin() ) :
+if (source in e ) :
+stream._destin[i] = source
+break
+else :
+stream._destin = [source]
+# Checks the options for all commands and actions.
+kwarg = _getopt( ui, cmd, kwarg )
+stamp = kwarg.pop( "stamp", None )
+if (stamp) :
+def stamp_commit_message( opts ) :
+msg = opts["message"]
+if (0 > msg.lower().find( stamp.lower() )) :
+msg += " %s" % stamp
+opts["message"] = msg
+return opts
+commands.reg_option_mutator( "commit", stamp_commit_message )
+func = func.get( cmd, lambda *arg, **kwarg : flow.action( stream, *arg, **kwarg ) )
+func( *arg, **kwarg )
+except AbortFlow, e :
+errmsg = e.error_message()
+_error( ui, *errmsg )
+if (getattr( e, "note", None )) :
+_note( ui, *((e.note,) if (isinstance( e.note, str )) else e.note), via_quiet = True )
+if (ui.tracebackflag) :
+if (hasattr( e, "traceback" )) :
+ei = e.traceback
+sys.excepthook( ei[0], ei[1], ei[2] )
+print
+ei = sys.exc_info()
+sys.excepthook( ei[0], ei[1], ei[2] )
+commands.print_history()
+try :
+os.chdir( flow.orig_dir )
+except :
+_print( ui, "The original dir is gone in file system (probably due to updating branch)." )
+_print( ui, "You are now in the root dir of the repository." )
+# On Windows, a topic should be wrapped with quotes.
+if ("nt" == os.name) :
+flow_cmd.__doc__ = flow_cmd.__doc__.replace( "help @help", 'help "@help"' )
+class Help( object ) :
+"""
+Online help system
+We define all help topics within this class.
+We support text effects on help message. See C{colortable} for predefined effects as C{flow.help.*}. To make it easy to use
+text effects, we invented a primitive markdown syntax. For now, we support only the C{flow.help.code}, which will be
+applied to text wrapped with '{{{' and '}}}'.
+"""
+SHORT_USAGE = """
+flow: a Mercurial workflow extension
+Usage: {{{hg flow {<stream> [<action> [<arg>...]] | <command>} [<option>...]}}}
+""" + flow_cmd.__doc__
+TOPIC = {
+"@deprecated" : """
+The following item has been deprecated in this release and will be removed in
+the future:
+* [hgflow]   The '[hgflow]' section name in hg's configuration file has been
+renamed to '[flow]'.
+""",
+"@examples" : """
+{{{> hg flow}}}
+flow: Currently open branches:
+flow: <master> : default
+flow: <develop>: develop develop/0.9#
+flow: <feature>: feature/help*
+# Show open branches in all streams. The '*' marker indicates the branch which
+# the workspace is in, and the '#' marker indicates there are shelved changes
+# in the branch.
+{{{> hg flow feature finish --history}}}
+# Finish the current <feature> branch, and print the history of primitive hg
+# commands used by the workflow.
+{{{> hg flow develop/0.9:feature start new_v0.9_feature}}}
+# Start a new feature branch from the 'develop/0.9' branch.
+{{{> hg flow develop/0.9:feature finish --verbose}}}
+flow: note: Hg command history:
+flow: note:   hg commit --message "flow: Closed <feature> 'help'." --close-branch
+flow: note:   hg update develop/0.9
+flow: note:   hg merge feature/help
+flow: note:   hg commit --message "flow: Merged <feature> 'help' to <develop/0.9> ('develop/0.9')."
+flow: note:   hg update develop
+flow: note:   hg merge develop/0.9
+flow: note:   hg commit --message "flow: Merged <develop/0.9:feature> 'help' to <develop> ('develop')."
+# Finish the workspace <feature> branch, merging it to 'develop/0.9', which is
+# in turn merged to <develop>'s trunk.
+""",
+"@master" : """
+Master stream contains 1 and only 1 branch that has only and all production
+revisions (i.e., official releases). New revisions in <master> are created when
+a <release> or <hotfix> branch merges into <master>.
+The following actions can be applied to <master>: push, publish, pull, list,
+and log.
+""",
+"@develop" : """
+Develop stream contains all changes made for future releases. <release> and
+<feature> branches are started from <develop> and will be merged to <develop>
+when finished. Since version 0.9, user can create branches in <develop>. A
+<develop> branch can be used as the source branch to start <release> and
+<feature> branches.
+""",
+"@feature" : """
+Feature stream contains branches where new features for future releases are
+developed. Branches in <feature> are created from either <develop> or an
+existing <feature> branch.
+All actions can be applied to <feature> branches. When a <feature> branch is
+finished, it will normally be merged into <develop>.
+""",
+"@release" : """
+Release stream contains branches of release candidates. Code in <release> branch
+will usually be tested and bug-fixed. Once a <release> branch is graduated from
+the testing and bug-fixing process, it will be merged to both <master> and
+<develop>.
+""",
+"@hotfix" : """
+Hotfix stream contains branches for fixing bugs in <master>. <hotfix> branches
+are started from <master> and once they are finished will be merged to both
+<master> and <develop>.
+""",
+"@support" : """
+Support stream contains branches for supporting a previous release. <support>
+branches are started from <master> and will never be merged to anywhere. When
+finished, they will be simply closed.
+""",
+"@start" : """
+Start a new branch in stream. <feature> and <release> branches are started from
+<develop>. <hotfix> and <support> branches are started from <master>.
+syntax:
+{{{hg flow <stream> start <name> [<option>...]}}}
+options:
+-r --rev REV       Revision to start a new branch from.
+-m --message TEXT  Record TEXT as commit message when opening new branch.
+-p --stamp TEXT    Append TEXT to all commit messages.
+-d --date DATE     Record the specified DATE as commit date.
+-u --user USER     Use specified USER as committer.
+--dirty         Start a new branch from current dirty workspace branch and
+move all uncommitted changes to the new branch.
+The new branch is named after <stream-prefix>/<name>.
+""",
+"@finish" : """
+Finishing a branch in stream means to close the branch and merge the branch to
+destination stream(s). <feature> branches will be merged to <develop>, and
+<release> and <hotfix> branches will be merged to both <develop> and <master>.
+<support> branches will not be merged to anywhere, and they will only be closed.
+Note that merging to a non-trunk <develop> branch will cause the <develop>
+branch to be merged into the <develop> trunk.
+syntax:
+{{{hg flow <stream> finish [<option>...]}}}
+The workspace branch will be finished. Hgflow intentionally forbids finishing
+a branch other than the workspace one, which forces user to update to and
+check the branch before finishing it.
+The workspace branch must be in the specified <stream>. When the workspace
+branch is merged into <master>, a new tag will be added to the corresponding
+snapshot in the <master> trunk. User can use the '-t' option to specify the tag
+name; if not specified, the tag name will be derived automatically from the
+name of the workspace branch by replacing the stream prefix with the
+`version_prefix`. The '-t' option has no effect if the workspace branch is not
+merged into <master>.
+options:
+-c --commit        Commit changes before closing the branch.
+-m --message TEXT  Record TEXT as commit message.
+-p --stamp TEXT    Append TEXT to all commit messages.
+-t --tag NAME      Tag the snapshot in the <master> trunk with NAME.
+-d --date DATE     Record the specified DATE as commit date.
+-u --user USER     Use specified USER as committer.
+-e --erase         Erase branch after it is merged successfully.
+N.B.: RE. '--erase': A branch cannot be erased if it has been previously merged
+to other branches, creating nodes that are not erased together with the branch.
+""",
+"@push" : """
+Push the workspace branch to the remote repository.
+syntax:
+{{{hg flow <stream> push}}}
+alternative syntax:
+{{{hg flow <stream> publish}}}
+The two syntaxes are completely equivalent.
+The workspace branch must be in <stream>.
+""",
+"@publish" : """
+Push the workspace branch to the remote repository.
+syntax:
+{{{hg flow <stream> publish}}}
+alternative syntax:
+{{{hg flow <stream> push}}}
+The two syntaxes are completely equivalent.
+The workspace branch must be in <stream>.
+""",
+"@pull" : """
+Pull a branch named after <stream-prefix>/<name> from the remote repository and
+update the workspace. If <name> is not specified, it defaults to the workspace
+branch.
+syntax:
+{{{hg flow <stream> pull [<name>]}}}
+The pulled branch must be in <stream>.
+""",
+"@list" : """
+List all open branches in <stream>.
+syntax:
+{{{hg flow <stream> list}}}
+alternative syntax:
+{{{hg flow <stream>}}}
+If <stream> has trunk (e.g., <develop> and <master>), this syntax will update
+the workspace to the trunk besides listing all open branches in <stream>. If
+<stream> does not have trunk (e.g., <feature>, <release>, <hotfix>, and
+<support>), this syntax is completely equivalent to the other one (i.e., only
+list all open branches in the stream).
+option:
+-c --closed    Show open and closed branches in <stream>.
+example:
+{{{> hg flow hotfix list}}}
+flow: Open <hotfix> branches:
+flow:   hotfix/0.9.6#
+flow:   hotfix/0.9.6/init_-d_option*
+# List all currently open branches in <hotfix>. The '*' marker indicates the
+# branch which the workspace is in, and the '#' marker indicates that there are
+# shelved changes for the branch.
+""",
+"@log" : """
+Show revision history of the specified branch, which must be in <stream>.
+syntax:
+{{{hg flow <stream> log [<basename>]}}}
+where <basename> is of the branch name, e.g., if a branch's name is
+'feature/colored_help', its basename relative to <feature> (assuming the
+branch name prefix is 'feature/') is 'colored_help'.
+If <basename> is missing, it will default to the workspace branch.
+Show revision history of a single file in the workspace branch.
+syntax:
+{{{hg flow <stream> log <filename>}}}
+If <filename> happens to be the same as the basename of a branch in <stream>,
+it will be recognized as the basename.
+alternative syntax:
+{{{hg flow <stream> log -F <filename>}}}
+Use this syntax to avoid the potential ambiguity with the prior syntax. Also,
+you can specify multiple file names to show revision history of these files.
+Show revision history of specified files in a designated branch.
+syntax:
+{{{hg flow <stream> log <basename> -F <filename>}}}
+options:
+-F --file FILE [+]  File to show history of.
+-d --date DATE      Show revisions matching date spec.
+-u --user USER      Show revisions committed by USER.
+-k --keyword TEXT   Do case-insensitive search for a given text.
+-p --patch          Show patch.
+-g --git            Use git extended diff format to show patch.
+-l --limit VALUE    Limit number of changesets displayed.
+-c --closed         Show closed branches when used together with -s option.
+[+] marked option can be specified multiple times.
+""",
+"@abort" : """
+Aborting the workspace branch can be done in two ways:
+1. The default way is simply marking the branch as closed so that it will not
+show up when you list alive branches, but all changesets in the branch
+remain in the repository and you cannot reuse the branch's name for a
+different branch.
+2. The other way is erasing the branch, in other words, completely deleting the
+branch and all changesets in it from the repository. This way is
+devastating, but you can clear unneeded changesets and reuse the branch's
+name. To abort a branch in this way, you just add the {{{-e}}} option.
+N.B.: A branch cannot be erased if you have previously merged it to other
+branches that remain in the repository.
+syntax:
+{{{hg flow <stream> abort [-m <TEXT>] [-e]}}}
+options:
+-m --message TEXT  Record TEXT as commit message when closing branch.
+-p --stamp TEXT    Append TEXT to all commit messages.
+-e --erase         Abort branch and erase it.
+""",
+"@promote" : """
+Merge the workspace branch to destination branches. The destination branches,
+if omitted, will default to the trunk of the destination stream. The destination
+streams of the basic streams are listed as follows:
+stream          destination
+------------+-----------------------
+<feature>    <develop>
+<develop>    <master>
+<release>    <develop> & <master>
+<hotfix>     <develop> & <master>
+<master>     n/a
+<support>    n/a
+natural      stream-trunk
+syntax:
+{{{hg flow <stream> promote [<destination-branch-full-name>...] [<option>...]}}}
+The workspace branch must be in <stream>. If the `-r` option is omitted, its
+value will default to the head of the workspace branch.
+options:
+-r --rev REV       Revision to promote to other branches.
+-m --message TEXT  Record TEXT as commit message when promoting branch.
+-p --stamp TEXT    Append TEXT to all commit messages.
+-t --tag NAME      Tag the merging changeset with NAME
+-d --date DATE     Record the specified DATE as commit date.
+-u --user USER     Use specified USER as committer.
+examples:
+{{{> hg flow develop promote -t v0.2.0}}}
+# Immediately release <develop> trunk's tip into <master>, bypassing <release>.
+# What this command exactly does is to promote the <develop> trunk into
+# <master> (<master> is <develop>'s default promotion destination, so you don't
+# have to spell it out in the command), and then label the <master> snapshot
+# with "v0.2.0".
+""",
+"@rebase" : """
+Rebase the workspace branch to the specified revision.
+syntax:
+{{{hg flow <stream> rebase [-d <rev>]}}}
+option:
+-p --stamp TEXT  Append TEXT to all commit messages.
+The workspace branch must be in <stream>. If the destination revision is not
+specified, it will default to the source branch of the workspace branch.
+""",
+"@version" : """
+Show version of the flow extension.
+syntax:
+{{{hg flow version}}}
+""",
+"@init" : """
+Initialize the flow extension for the repository. The configuration file:
+{{{.hgflow}}} will be written in the root dir of the repository. The file will be
+tracked by hg. If you have multiple open branches, the file should be present
+and synchronized in all of them -- init command will do this for you
+automatically.
+syntax:
+{{{hg flow init [<option>...]}}}
+options:
+-f --force       Force reinitializing flow.
+-u --user USER   Use specified USER as committer.
+-p --stamp TEXT  Append TEXT to all commit messages.
+""",
+"@upgrade" : """
+Upgrade the configuration file from v0.9.4 (or older) to v0.9.5 or later.
+syntax:
+{{{hg flow upgrade}}}
+options:
+-u --user USER   Use specified USER as committer.
+-p --stamp TEXT  Append TEXT to all commit messages.
+""",
+"@unshelve" : """
+Unshelve previously shelved changes by hgflow. Sometimes, unshelving is not
+automatically executed because workflow is terminated prematurelly. In such
+situations, you can always use the unshelve command to manually restore the
+shelved changes.
+syntax:
+{{{hg flow unshelve}}}
+""",
+"@terms" : """
+Concepts:
+- stream
+The entire set of branches of the same type. Stream is not branch, it is a
+set of branches. In general, a stream can contain any number (including zero)
+of branches. The master stream is, however, special in that it contains 1 and
+only 1 branch. The develop stream contains at least one branch.
+- basic streams
+Refers to the master, develop, feature, release, hotfix, and support streams
+as predefined in Driessen's model.
+- natural streams
+Refers to a set of branches that diverged from and will merge into the same
+branch. The set of branches plus the branch that they diverged from form a
+natural stream. The branch that all the other branches in the same natural
+stream diverged from and will merge into is the trunk of the natural stream.
+- trunk
+Trunk is a special branch. A stream can optionally have a trunk, but only one
+trunk at most. For example, master and develop streams each has a trunk,
+whereas feature, release, hotfix, and support streams don't. And all natural
+streams each has a trunk. If a stream has a trunk, all branches in the stream
+normally should diverge from the trunk and later merge to the trunk when they
+are finished.
+Trunk is a relative concept. A trunk of a stream may be a regular branch of
+another stream. (The former stream will be called a substream of the latter.)
+- source
+Source is an attribute of stream. The source of a stream refers to the stream
+where branches in the current stream are created from. A stream's source can
+be the stream itself. But this is not always the case, for example,
+the sources of release and feature streams are the develop stream.
+- destin
+Destin is another attribute of stream. The destin of a stream refers to the
+stream(s) where branches in the current stream will merge to. A stream's
+destin can be the stream itself. But this is not always the case,
+for example, the destin of release is the develop and the master streams.
+- fullname
+Branch name as recognized by the SCM, e.g., feature/enhance_log.
+- basename
+Branch name recognized by flow, but not necessarily by SCM, e.g.,
+enhanced_log (with prefix 'feature/' dropped).
+- flow action
+Refer to action on a specified stream, e.g., hg flow feature start, where
+'start' is an action.
+- flow command
+Commands don't act on a stream, e.g., hg flow unshelve, where 'unshelve'
+is a command.
+- hg command
+Refer to commands not from flow extension.
+- workflow
+Refer to the process of executing a sequence of hg commands.
+- history
+Refer to a sequence of executed hg commands.
+Notations
+- <stream>
+Examples: <feature>, <hotfix>. These denote the corresponding streams. When
+you refer to a stream, e.g., feature stream, use '<feature>' (or more
+verbosely 'feature stream'), instead of '<feature> stream', because
+'<feature>' already means stream.
+- <stream> branch
+Example: a <feature> branch. This phrase refers a branch in <feature>. Do not
+use 'a feature branch' to mean a branch in <feature> because the word
+'feature' there should take its usual meaning as in English, which doesn't
+necessarily mean the feature stream.
+""",
+"@help" : """
+Show online help and then quit. An argument can be optionally given after the
+'help' command to specify a particular help topic. Detailed online help is
+available for the following topics:
+@all        - Show detailed help for all supported topics.
+@<stream>   - Show help about a particular stream, e.g., {{{@feature}}}, {{{@master}}}.
+@<action>   - Show help about an action, e.g., {{{@finish,}}} {{{@log}}}.
+@<command>  - Show help about a command, e.g., {{{@help}}}, {{{@unshelve}}}.
+@terms      - Show explanations of terminologies used in hgflow.
+@examples   - Show a few command examples.
+@deprecated - Show a list of deprecated features.%s""" %  \
+("\nOn Windows platform, a topic should be wrapped with quotes, e.g., {{{\"@finish\"}}}." if ("nt" == os.name) else ""),
+}
+def __init__( self, ui, repo ) :
+self.ui   = ui
+self.repo = repo
+def _print( self, s ) :
+"""
+Print text with predefined effects.
+@type  s: C{str}
+@param s: String to be printed
+"""
+import re
+code_pattern = re.compile( "{{{.*?}}}" )
+last_span    = (0, 0,)
+for match in code_pattern.finditer( s ) :
+span = match.span()
+self.ui.write( s[last_span[1]:span[0]] )
+self.ui.write( s[span[0] + 3:span[1] - 3], label = "flow.help.code" )
+last_span = span
+self.ui.write( s[last_span[1]:] )
+def print_help( self, topic = None, *arg, **opts ) :
+"""
+Print help information.
+@type  topic : C{str} or C{None}
+@param topic : Help topic
+"""
+if (topic is None) :
+self._print( self.SHORT_USAGE )
+elif (topic == "@all") :
+doc = self.TOPIC.items()
+doc.sort()
+for t, help in doc :
+self.ui.write( "%s" % t, label = "flow.help.topic" )
+self._print( "%s\n" % help )
+else :
+try :
+help_content = self.TOPIC[topic]
+self.ui.write( "%s" % topic, label = "flow.help.topic" )
+self._print( "%s\n" % help_content )
+except KeyError :
+_error( self.ui, "Unknown topic: %s" % topic )
+if (("@" + topic) in self.TOPIC or topic == "all") :
+_error( self.ui, "Did you mean '@%s'?" % topic )
+_print( self.ui, """Supported topics are the following:
+@all        - Show detailed help for all supported topics.
+@<stream>   - Show help about a particular stream, e.g., @feature, @master.
+@<action>   - Show help about an action, e.g., @finish, @log.
+@<command>  - Show help about a command, e.g., @help, @unshelve.
+@<option>   - Show help about an option, e.g., @-F, @--history.
+@examples   - Show a few command examples.
+@deprecated - Show a list of deprecated features.
+""" )
+OPT_FILTER = {
+"init"    : ("force", "user", "stamp", "default",),
+"upgrade" : ("user", "stamp",),
+"start"   : ("rev", "message", "stamp", "date", "user", "dirty",),
+"finish"  : ("commit", "message", "stamp", "tag", "date", "user", "erase", "onstream",),
+"list"    : ("closed",),
+"log"     : ("file", "date", "user", "keyword", "patch", "git", "limit", "graph", "closed", "onstream",),
+"abort"   : ("erase", "message", "stamp", "onstream",),
+"promote" : ("rev", "message", "stamp", "tag", "date", "user", "onstream",),
+"rebase"  : ("dest", "onstream", "stamp",),
+}
+OPT_CONFLICT = {
+"dest"    : ("-d", '',   ),     # (short-form-of-option, default-value,)
+"date"    : ("-d", '',   ),
+"default" : ("-d", False,),
+"closed"  : ("-c", False,),
+"commit"  : ("-c", False,),
+"stamp"   : ("-p", ''    ),
+"patch"   : ("-p", False ),
+}
+def _getopt( ui, key, opt ) :
+"""
+Return user-specified options.
+We cannot separate options for different subcommands because of the design of the C{cmdtable}. So ambiguity exists for some
+options. For example, the C{-d} option, it means C{dest} for C{rebase} and C{date} for C{finish}. For either of the two
+actions, the value of the C{-d} option could be saved in C{dest} or C{date}. In general, we don't know which one.
+We have to do a bit of parsing to resolve potential ambiguity. This function is here for that purpose. C{opt} is the raw
+option C{dict} from C{hg}. We will reparse it a bit for a particular command or action given by C{key}. The function
+returns a C{dict} that contains the option's name and its value.
+N.B.:
+(1) If the value of an option evaluates to false, the option will be absent in the returned C{dict} object.
+(2) This function will mutate and return C{opt}.
+@type   ui: C{mercurial.ui}
+@param  ui: Mercurial user interface object
+@type  key: C{str}
+@param key: Command or action for which you are getting the options
+@type  opt: C{dict}
+@param opt: Raw options
+@raise AbortFlow: AbortFlow exception will be raised if there is option error.
+"""
+ret       = {}
+rec_short = []    # A list of recoginized short options
+for e in OPT_FILTER.get( key, [] ) :
+if (opt.get( e )) :
+ret[e] = opt[e]
+elif (e in OPT_CONFLICT) :
+short_opt, default_value = OPT_CONFLICT[e]
+argv = sys.argv
+if (short_opt in argv) :
+rec_short.append( short_opt )
+if (isinstance( default_value, str )) :
+index  = argv.index( short_opt )
+try :
+ret[e] = argv[index + 1]
+except IndexError :
+raise AbortFlow( "Value not found for %s option." % short_opt )
+else :
+ret[e] = not default_value
+bad_opt = [e for e in     opt if (e not in (["history", "dry_run"] + ret.keys()) and opt[e])]
+bad_opt = [e for e in bad_opt if (e in sys.argv) or (OPT_CONFLICT.get( e, [0,] )[0] not in rec_short)]
+if (bad_opt) :
+bad_opt = [e.replace( "_", "-" ) for e in bad_opt]
+if (key is None) :
+raise AbortFlow( "Unrecognized option%s for `hg flow`: %s." %
+("" if (len( bad_opt ) == 1) else "s", "--" + (", --".join( bad_opt )),),
+note = "`hg flow` should take no options." )
+else :
+raise AbortFlow( "Unrecognized option%s for `%s`: %s." %
+("" if (len( bad_opt ) == 1) else "s", key, "--" + (", --".join( bad_opt )),),
+note = "Execute `hg flow help @%s` to see available options for `%s`." % (key, key,) )
+return ret
+cmdtable = {
+"flow" :
+(flow_cmd,
+[("",  "history",   False, _("Print history of hg commands used in this workflow."),                          ),
+("",  "dry-run",   None,  _("Do not perform actions, just print history."),                                  ),
+("",  "dirty",     False, _("Start a new branch from a dirty workspace, and move all"
+" uncommitted changes to the new branch. [start]"),                              ),
+("c", "closed",    False, _("Show normal and closed branches in stream. [list, log]"),                       ),
+("c", "commit",    False, _("Commit changes before closing the branch. [finish]"),                           ),
+("d", "default",   False, _("Initialize flow with default configuration. [init]"),                           ),
+("d", "date",      '',    _("Record the specified date as commit date. [start, finish, promote]"), _('DATE'),),
+("d", "date",      '',    _("Show revisions matching date spec. [log]"),                           _('DATE'),),
+("d", "dest",      '',    _("Destination changeset of rebasing. [rebase]"),                        _('REV' ),),
+("e", "erase",     False, _("Erase branch after it is merged or aborted successfully. [finish, abort]"),     ),
+("F", "file",      [],    _("File to show history of. [log]"),                                     _('FILE'),),
+("f", "force",     False, _("Force reinitializing flow. [init]"),                                            ),
+("g", "git",       False, _("Use git extended diff format to show patch. [log]"),                            ),
+("k", "keyword",   '',    _("Do case-insensitive search for a given text. [log]"),                 _('TEXT'),),
+("l", "limit",     '',    _("Limit number of changesets displayed. [log]"),                                  ),
+("m", "message",   '',    _("Record TEXT as commit message. [start, finish, promote, abort]"),     _('TEXT'),),
+("p", "stamp",     '',    _("Append TEXT to all commit messages. [init, upgrade, start, finish,"
+" promote, rebase, abort]"),                                           _('TEXT'),),
+("p", "patch",     False, _("Show patch. [log]"),                                                            ),
+("r", "rev",       '',    _("Revision to start a new branch from. [start]"),                       _('REV'), ),
+("r", "rev",       '',    _("Revision to promote to other branches. [promote]"),                   _('REV'), ),
+("s", "onstream",  False, _("Act on stream. [finish, rebase, log, abort]"),                                  ),
+("t", "tag",       '',    _("Tag the merging changeset with NAME. [promote]"),                     _('NAME'),),
+("t", "tag",       '',    _("Tag the <master> trunk with NAME after merging. [finish]"),           _('NAME'),),
+("u", "user",      '',    _("Use specified user as committer. [init, upgrade, start, finish,"
+" promote]"),                                                          _('USER'),),
+("u", "user",      '',    _("Show revisions committed by specified user. [log]"),                  _('USER'),),
+],
+"hg flow {<stream> [<action> [<arg>]] | <command>} [<option>...]",
+),
+}

Mercurial > hg > mhoward > dotfiles / file comparison

comparison: .hgext/hgflow.py

.hgext/hgflow.py