new file mode 100644
--- /dev/null
+++ b/.hgext/hgflow.py
@@ -0,0 +1,2930 @@
+"""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>...]",
+ ),
+}