mhoward/dotfiles: comparison .hgext/hgflow.py

-:809a691bfa2e
+:cd4f24b84a3e
-"""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>...]",
-),
-}

Mercurial > hg > mhoward > dotfiles / file comparison

comparison: .hgext/hgflow.py

.hgext/hgflow.py