Mercurial > hg > mhoward > dotfiles / file revision

"""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-2014, Yujie Wu and others
#
# 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.8"
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 = {}

        self.reg_option_mutator( "strip", lambda opts : dict( {"rev" : [],},                                 **opts ) )
        self.reg_option_mutator( "graft", lambda opts : dict( {"rev" : [], "continue" : False,},             **opts ) )
        self.reg_option_mutator( "log",   lambda opts : dict( {"date" : None, "user" : None, "rev" : None,}, **opts ) )

        
    
    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 sorted( kwarg.items(), reverse = True ) :
            if (value in [None, "", False]) :
                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 C{value} is a string that contains space, slash, double quote, and parenthesis (viz: '(' or ')'), wrap it with
        double quotes and properly escape the double-quotes and slashes within, and finally return the modified string.
        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  : Mercurial 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 ) :
        """
        Call the registered command option mutator for the command and return the modified command options.
        
        @type  where: module
        @param where: Should be `mercurial.commands', or a Mercurial's plugin object.
        @type  cmd  : C{str}
        @param cmd  : Mercurial command name
        @type  opts : C{dict}
        @param opts : Original command options
        
        @rtype: C{dict}
        """
        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.

        @type  via_quiet: C{bool}
        @param via_quiet: To turn off using the "quiet" channel for history printing, you can call this function like:
                          C{use_quiet_channel( False )}.
        """
        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.

        @type  via_verbose: C{bool}
        @param via_verbose: To turn off using the "verbose" channel for history printing (you will be using the "quiet"
                            channel instead), you can call this function like: C{use_verbose_channel( False )}.
        """
        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  cmd    : C{str}
        @param cmd    : Mercurial command name
        @type  mutator: Callable object
        @param mutator: It will take a C{dict} object as its argument and return another C{dict} object that is supposed to be
                        a mutant of the former. The input object is supposed to be the original hg-command options in form of
                        key-value pairs.
        """
        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. It can be a complex stream name, e.g., "develop/spring:release".
        @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
        """
        source = None
        tokens = name.split( ':' )
        n      = len( tokens )
        if (n == 2) :
            source, name = tokens[0], tokens[1]
        if (n > 2 or not name) :
            raise AbortFlow( "Invalid stream syntax: '%s'" % stream )

        for e in STREAM.values() :
            if (name == e.name()) :
                if (source) :
                    stream = copy.copy( e )
                    break
                else :
                    return e
        else :
            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 , e :
                    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 )

        # It seems we never really mind abnormal streams. So comment this out.
        #if (not is_normalstream) :
        #    raise AbnormalStream( stream = Stream( ui, repo, name ) )

        if (source) :
            source = Stream.gen( ui, repo, source, check = True )
            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]

        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 and this stream has no trunk, 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 )

        all_branches = []
        if (openclosed == "open") :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads
                                 if (not self.repo[head].extra().get( "close", False ))]
        elif (openclosed == "closed") :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads
                                 if (self.repo[head].extra().get( "close", False ))]
        else :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads]

        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
        @type  should_quote: C{bool}
        @param should_quote: The returned string will be wrapped with single quotes ' if this parameter's value is true.
        """
        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 rev_node( self ) :
        """
        Return a string showing this branch's head's revision number and short node ID in the format of "<rev>:<node-ID>",
        e.g., "9:db14bf692069".
        """
        return "%s:%s" % (self.ctx.rev(), short( self.ctx.node() ),)



    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 ) :

    ACTION_NAME = ["start", "finish", "push", "publish", "pull", "list", "log", "abort", "promote", "rebase", "rename",]

    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: Basename of the path 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 )

        all_branches = []
        if (openclosed == "open") :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads
                                 if (not self.repo[head].extra().get( "close", False ))]
        elif (openclosed == "closed") :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads
                                 if (self.repo[head].extra().get( "close", False ))]
        else :
            for branch_fullname, heads in self.repo.branchmap().items() :
                all_branches += [Branch( self.ui, self.repo, head ) for head in heads]

        return all_branches



    def _find_branch( self, fullname ) :
        """
        Try to find a branch of name: C{fullname}. If it exists, return a C{Branch} object of this branch and a boolean value
        indicating if it's open (C{True}) or closed (C{False}). If it does not exists, return C{(None, None)}.

        @type  fullname: C{str}
        @param fullname: Fullname of the branch to find
        """
        try :
            branch = Branch( self.ui, self.repo, fullname )
            return branch, branch.is_open()
        except error.RepoLookupError :
            return None, None

    
    
    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 )
        br, is_open = self._find_branch( fullname )
        if (br) :
            self._error( "A branch named '%s' already exists in %s: '%s'." % (basename, stream, fullname,) )
            if (not is_open) :
                self._note( "Branch '%s' is currently closed." % fullname, via_quiet = True )
        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 ""
                marker += "  %s" % e.rev_node()
                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( " %18s" % e.rev_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,]

        opts = {"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
        """
        arg            = arg[1:]
        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 (arg) :
            if (len( arg ) > 1 or curr_workspace.basename() != arg[0]) :
                raise AbortFlow( "hgflow intentionally forbids aborting a non-workspace branch." )
        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( branch, self.repo.revs( "min(branch('%s'))" % branch )[0] )
                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( curr_workspace, self.repo.revs( "min(branch('%s'))" % curr_workspace )[0] )
            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 _action_rename( self, stream, *arg, **kwarg ) :
        """
        Rename the workspace branch to a new basename. If there are uncommitted changes in the current branch, they will be
        automatically shelved before renaming and unshelved afterwards.
        Under the hood this action will create a new branch and copy (or graft) all commits in the workspace branch to the new
        branch and then erase the workspace branch.

        @type  stream: C{Stream}
        @param stream: Stream where the branch which you want to rename is
        @type  to    : C{str}
        @param to    : Its value should be the new basename of the workspace branch.
        """
        new_branch_name = kwarg.pop( "to", None )
        curr_workspace  = self.curr_workspace
        if (not new_branch_name) :
            raise AbortFlow( "Please specify the new base name of this branch via the `-t` option." )
        if (curr_workspace not in stream) :
            raise AbortFlow( "Your workspace is '%s' branch, which is not in %s." % (curr_workspace, stream,),
                             "To rename a %s branch, you must first update to it." % stream )
        if (curr_workspace.is_trunk( stream )) :
            raise AbortFlow( "You cannot rename the trunk of %s." % stream )
        if (new_branch_name == curr_workspace.basename( stream )) :
            self._warn( "No effects because the supposed new basename turns out to be the same as the current one." )
        else :
            cfn = curr_workspace.fullname()
            brn = "branch(%s)" % cfn
            rev = "min(%s)" % brn
            ctx = self.repo[self.repo.revs( rev )[0]]
            nfn = stream.get_fullname( new_branch_name )
            msg = ctx.description()
            msg = msg.replace( cfn, nfn )
            self._shelve()
            self._update( self.repo.revs( "%s^" % rev )[0] )
            self._create_branch( nfn, msg, user = ctx.user(), date = util.datestr( ctx.date() ) )
            self._graft( curr_workspace, **kwarg )
            self._unshelve( cfn )
            self._strip( curr_workspace, int( ctx ) )
    
    
    
    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()
        self._print( "Parent of working directory: %s" % branch.rev_node() )


    
    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, Flow.ACTION_NAME, 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
            if (stream != STREAM["master"]) :
                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_orig  = tag_name
        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 from the current branch and named after the pattern:
        # <stream-prefix>/<current-branch-basename>. Afterwards, the current branch will be closed.
        # Note that there is no need to merge the current branch because the new branch is 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       = Stream.gen( self.ui, self.repo, "%s:%s" % (so.name(), s.name(),), check = True )
            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 )

        if (tag_name_orig and (STREAM["master"] not in destin_with_trunk)) :
            self._warn( "You specified a tag name, but it has effect only when the workspace branch is merged to <master>." )
                
        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, force = True )
            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 ( curr_workspace, self.repo.revs( "min(branch('%s'))" % curr_workspace )[0] )
            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,
            "rename"  : self._action_rename,
            "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.

        @type  stream: C{Stream}
        @param stream: Stream where we will execute the action
        """
        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 :
            trunk = stream.trunk()
            self._update_workspace( 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()
        name_branches  = {}
        for branch in all_branches :
            name_branches.setdefault( branch.fullname(), [] ).append( branch )
        name_branches = sorted( name_branches.items() )
        for sn in stream_names :
            stream = STREAM[sn]
            trunk  = stream.trunk()
            open_branches_in_stream = []
            for name, heads in name_branches :
                e = heads[0]
                if (e in stream) :
                    open_branches_in_stream.append( e )
            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" )
        if (sum( [len( heads ) - 1 for name, heads in name_branches] )) :
            self._print( "\n", newline = False )
            self._print( "Multihead branches:" )
            for name, heads in name_branches :
                if (len( heads ) > 1) :
                    self._print( "  %s" % name )
                    for head in heads :
                        self._print( "    %s" % head.rev_node() )
            
    
     
    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.
            if (not commands.dryrun()) :
                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()

        master_trunk, is_open = self._find_branch( master_stream )
        if (master_trunk and not is_open) :
            self._warn( "Branch \"%s\" is currently closed." % master_stream )
            self._warn( "Will reopen and use it as <master> trunk."          )
            branches.append( master_trunk )
            
        develop_trunk, is_open = self._find_branch( develop_stream )
        if (develop_trunk and not is_open) :
            self._warn( "Branch \"%s\" is currently closed." % develop_stream )
            self._warn( "Will reopen and use it as <develop> trunk."          )
            branches.append( develop_trunk )
            
        # 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 (master_trunk is None) :
            self._create_branch( master_stream, "flow initialization: Created <master> trunk: %s." % master_stream )
        if (develop_trunk is None) :
            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.
- rename   Rename workspace branch to a new basename.
- 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 )) :
            stream = Stream.gen( ui, repo, stream, check = True )
            
        # 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 )
        elif (errmsg[0].startswith( "Stream not found" )) :
            misspelling = difflib.get_close_matches( stream, ["init", "upgrade", "unshelve", "help", "version",], 3, 0.7 )
            note = ("Did you mean the command: %s?" % " or ".join( misspelling )) if (misspelling        ) else None
            note = ("Did you mean the command: init?")                            if ("install" == stream) else note
            note = ("Did you mean the command: upgrade?")                         if ("update"  == stream) else note
            if (note) :
                _note( ui, 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]'.
  * Syntax: hg flow <stream> finish {{{<tag-name>}}}
               Replacement syntax: hg flow <stream> finish {{{-t <tag-name>}}}
               Any positional arguments for `finish` will be considered as
               error.
""",

"@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}}}
""",
        
"@rename" : """
Rename the workspace branch to a new basename. Under the hood, this action
will create a new branch with the new basename and copy/graft the commits in
the workspace branch to the new branch, and then erase the workspace branch.
All the user, date, and commit-message information will be copied to the
new branch.

N.B.: The workspace branch should be a simple linear branch. This means:
(1) It has not merged to other branches;
(2) It has no subbranches;
(3) No other branches has merged to this branch.

syntax:
{{{hg flow <stream> rename [-t <basename>]}}}

option:
 -t --to NAME  Rename the basename of the workspace branch to NAME.

The workspace branch must be in <stream>.
""",
        
"@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.
  @terms      - Show explanations of terminologies used in hgflow.
  @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",),
"rename"  : ("to",),
}

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 ),
"tag"     : ("-t", ''    ),
"to"      : ("-t", ''    ),
}

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." )
        elif (key in Flow.ACTION_NAME) :
            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,) )
        else :
            raise AbortFlow( "Unrecognized option%s: %s." %
                             ("" if (len( bad_opt ) == 1) else "s", "--" + (", --".join( bad_opt )),) )
            
    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'),),
      ("t", "to",        '',    _("Rename the branch to NAME. [rename]"),                                _('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>...]",
     ),
}