remove unused imports

hgext/color.py

@@ -1,482 +1,482
 # color.py color output for the status and qseries commands
 #
 # Copyright (C) 2007 Kevin Christen <[e-mail]>
 #
 # 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 (at your
 # option) 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.
 #
 # You should have received a copy of the GNU General Public License along
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 '''colorize output from some commands
 
 This extension modifies the status and resolve commands to add color
 to their output to reflect file status, the qseries command to add
 color to reflect patch status (applied, unapplied, missing), and to
 diff-related commands to highlight additions, removals, diff headers,
 and trailing whitespace.
 
 Other effects in addition to color, like bold and underlined text, are
 also available. By default, the terminfo database is used to find the
 terminal codes used to change color and effect.  If terminfo is not
 available, then effects are rendered with the ECMA-48 SGR control
 function (aka ANSI escape codes).
 
 Default effects may be overridden from your configuration file::
 
   [color]
   status.modified = blue bold underline red_background
   status.added = green bold
   status.removed = red bold blue_background
   status.deleted = cyan bold underline
   status.unknown = magenta bold underline
   status.ignored = black bold
 
   # 'none' turns off all effects
   status.clean = none
   status.copied = none
 
   qseries.applied = blue bold underline
   qseries.unapplied = black bold
   qseries.missing = red bold
 
   diff.diffline = bold
   diff.extended = cyan bold
   diff.file_a = red bold
   diff.file_b = green bold
   diff.hunk = magenta
   diff.deleted = red
   diff.inserted = green
   diff.changed = white
   diff.trailingwhitespace = bold red_background
 
   resolve.unresolved = red bold
   resolve.resolved = green bold
 
   bookmarks.current = green
 
   branches.active = none
   branches.closed = black bold
   branches.current = green
   branches.inactive = none
 
 The available effects in terminfo mode are 'blink', 'bold', 'dim',
 'inverse', 'invisible', 'italic', 'standout', and 'underline'; in
 ECMA-48 mode, the options are 'bold', 'inverse', 'italic', and
 'underline'.  How each is rendered depends on the terminal emulator.
 Some may not be available for a given terminal type, and will be
 silently ignored.
 
 Because there are only eight standard colors, this module allows you
 to define color names for other color slots which might be available
 for your terminal type, assuming terminfo mode.  For instance::
 
   color.brightblue = 12
   color.pink = 207
   color.orange = 202
 
 to set 'brightblue' to color slot 12 (useful for 16 color terminals
 that have brighter colors defined in the upper eight) and, 'pink' and
 'orange' to colors in 256-color xterm's default color cube.  These
 defined colors may then be used as any of the pre-defined eight,
 including appending '_background' to set the background to that color.
 
 The color extension will try to detect whether to use terminfo, ANSI
 codes or Win32 console APIs, unless it is made explicit; e.g.::
 
   [color]
   mode = ansi
 
 Any value other than 'ansi', 'win32', 'terminfo', or 'auto' will
 disable color.
 
 '''
 
-import os, sys
+import os
 
 from mercurial import commands, dispatch, extensions, ui as uimod, util
 from mercurial.i18n import _
 
 # start and stop parameters for effects
 _effects = {'none': 0, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33,
             'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37, 'bold': 1,
             'italic': 3, 'underline': 4, 'inverse': 7,
             'black_background': 40, 'red_background': 41,
             'green_background': 42, 'yellow_background': 43,
             'blue_background': 44, 'purple_background': 45,
             'cyan_background': 46, 'white_background': 47}
 
 def _terminfosetup(ui):
     '''Initialize terminfo data and the terminal if we're in terminfo mode.'''
 
     global _terminfo_params
     # If we failed to load curses, we go ahead and return.
     if not _terminfo_params:
         return
     # Otherwise, see what the config file says.
     mode = ui.config('color', 'mode', 'auto')
     if mode not in ('auto', 'terminfo'):
         return
 
     _terminfo_params.update((key[6:], (False, int(val)))
         for key, val in ui.configitems('color')
         if key.startswith('color.'))
 
     try:
         curses.setupterm()
     except curses.error, e:
         _terminfo_params = {}
         return
 
     for key, (b, e) in _terminfo_params.items():
         if not b:
             continue
         if not curses.tigetstr(e):
             # Most terminals don't support dim, invis, etc, so don't be
             # noisy and use ui.debug().
             ui.debug("no terminfo entry for %s\n" % e)
             del _terminfo_params[key]
     if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):
         ui.warn(_("no terminfo entry for setab/setaf: reverting to "
           "ECMA-48 color\n"))
         _terminfo_params = {}
 
 try:
     import curses
     # Mapping from effect name to terminfo attribute name or color number.
     # This will also force-load the curses module.
     _terminfo_params = {'none': (True, 'sgr0'),
                         'standout': (True, 'smso'),
                         'underline': (True, 'smul'),
                         'reverse': (True, 'rev'),
                         'inverse': (True, 'rev'),
                         'blink': (True, 'blink'),
                         'dim': (True, 'dim'),
                         'bold': (True, 'bold'),
                         'invisible': (True, 'invis'),
                         'italic': (True, 'sitm'),
                         'black': (False, curses.COLOR_BLACK),
                         'red': (False, curses.COLOR_RED),
                         'green': (False, curses.COLOR_GREEN),
                         'yellow': (False, curses.COLOR_YELLOW),
                         'blue': (False, curses.COLOR_BLUE),
                         'magenta': (False, curses.COLOR_MAGENTA),
                         'cyan': (False, curses.COLOR_CYAN),
                         'white': (False, curses.COLOR_WHITE)}
 except ImportError:
     _terminfo_params = False
 
 _styles = {'grep.match': 'red bold',
            'bookmarks.current': 'green',
            'branches.active': 'none',
            'branches.closed': 'black bold',
            'branches.current': 'green',
            'branches.inactive': 'none',
            'diff.changed': 'white',
            'diff.deleted': 'red',
            'diff.diffline': 'bold',
            'diff.extended': 'cyan bold',
            'diff.file_a': 'red bold',
            'diff.file_b': 'green bold',
            'diff.hunk': 'magenta',
            'diff.inserted': 'green',
            'diff.trailingwhitespace': 'bold red_background',
            'diffstat.deleted': 'red',
            'diffstat.inserted': 'green',
            'ui.prompt': 'yellow',
            'log.changeset': 'yellow',
            'resolve.resolved': 'green bold',
            'resolve.unresolved': 'red bold',
            'status.added': 'green bold',
            'status.clean': 'none',
            'status.copied': 'none',
            'status.deleted': 'cyan bold underline',
            'status.ignored': 'black bold',
            'status.modified': 'blue bold',
            'status.removed': 'red bold',
            'status.unknown': 'magenta bold underline'}
 
 
 def _effect_str(effect):
     '''Helper function for render_effects().'''
 
     bg = False
     if effect.endswith('_background'):
         bg = True
         effect = effect[:-11]
     attr, val = _terminfo_params[effect]
     if attr:
         return curses.tigetstr(val)
     elif bg:
         return curses.tparm(curses.tigetstr('setab'), val)
     else:
         return curses.tparm(curses.tigetstr('setaf'), val)
 
 def render_effects(text, effects):
     'Wrap text in commands to turn on each effect.'
     if not text:
         return text
     if not _terminfo_params:
         start = [str(_effects[e]) for e in ['none'] + effects.split()]
         start = '\033[' + ';'.join(start) + 'm'
         stop = '\033[' + str(_effects['none']) + 'm'
     else:
         start = ''.join(_effect_str(effect)
                         for effect in ['none'] + effects.split())
         stop = _effect_str('none')
     return ''.join([start, text, stop])
 
 def extstyles():
     for name, ext in extensions.extensions():
         _styles.update(getattr(ext, 'colortable', {}))
 
 def configstyles(ui):
     for status, cfgeffects in ui.configitems('color'):
         if '.' not in status or status.startswith('color.'):
             continue
         cfgeffects = ui.configlist('color', status)
         if cfgeffects:
             good = []
             for e in cfgeffects:
                 if not _terminfo_params and e in _effects:
                     good.append(e)
                 elif e in _terminfo_params or e[:-11] in _terminfo_params:
                     good.append(e)
                 else:
                     ui.warn(_("ignoring unknown color/effect %r "
                               "(configured in color.%s)\n")
                             % (e, status))
             _styles[status] = ' '.join(good)
 
 class colorui(uimod.ui):
     def popbuffer(self, labeled=False):
         if labeled:
             return ''.join(self.label(a, label) for a, label
                            in self._buffers.pop())
         return ''.join(a for a, label in self._buffers.pop())
 
     _colormode = 'ansi'
     def write(self, *args, **opts):
         label = opts.get('label', '')
         if self._buffers:
             self._buffers[-1].extend([(str(a), label) for a in args])
         elif self._colormode == 'win32':
             for a in args:
                 win32print(a, super(colorui, self).write, **opts)
         else:
             return super(colorui, self).write(
                 *[self.label(str(a), label) for a in args], **opts)
 
     def write_err(self, *args, **opts):
         label = opts.get('label', '')
         if self._colormode == 'win32':
             for a in args:
                 win32print(a, super(colorui, self).write_err, **opts)
         else:
             return super(colorui, self).write_err(
                 *[self.label(str(a), label) for a in args], **opts)
 
     def label(self, msg, label):
         effects = []
         for l in label.split():
             s = _styles.get(l, '')
             if s:
                 effects.append(s)
         effects = ''.join(effects)
         if effects:
             return '\n'.join([render_effects(s, effects)
                               for s in msg.split('\n')])
         return msg
 
 
 def uisetup(ui):
     global _terminfo_params
     if ui.plain():
         return
 
     formatted = (os.environ.get('TERM') != 'dumb' and ui.formatted())
     mode = ui.config('color', 'mode', 'auto')
     if mode == 'auto':
         if os.name == 'nt' and 'TERM' not in os.environ:
             # looks line a cmd.exe console, use win32 API or nothing
             mode = w32effects and 'win32' or 'none'
         else:
             if not formatted:
                 _terminfo_params = False
             else:
                 _terminfosetup(ui)
                 if not _terminfo_params:
                     mode = 'ansi'
                 else:
                     mode = 'terminfo'
     if mode == 'win32':
         if w32effects is None:
             # only warn if color.mode is explicitly set to win32
             ui.warn(_('warning: failed to set color mode to %s\n') % mode)
             return
         _effects.update(w32effects)
     elif mode == 'ansi':
         _terminfo_params = {}
     elif mode == 'terminfo':
         _terminfosetup(ui)
     else:
         return
     def colorcmd(orig, ui_, opts, cmd, cmdfunc):
         coloropt = opts['color']
         auto = coloropt == 'auto'
         always = util.parsebool(coloropt)
         if (always or
             (always is None and auto and formatted)):
             colorui._colormode = mode
             colorui.__bases__ = (ui_.__class__,)
             ui_.__class__ = colorui
             extstyles()
             configstyles(ui_)
         return orig(ui_, opts, cmd, cmdfunc)
     extensions.wrapfunction(dispatch, '_runcommand', colorcmd)
 
 def extsetup(ui):
     commands.globalopts.append(
         ('', 'color', 'auto',
          # i18n: 'always', 'auto', and 'never' are keywords and should
          # not be translated
          _("when to colorize (boolean, always, auto, or never)"),
          _('TYPE')))
 
 if os.name != 'nt':
     w32effects = None
 else:
     import re, ctypes
 
     _kernel32 = ctypes.windll.kernel32
 
     _WORD = ctypes.c_ushort
 
     _INVALID_HANDLE_VALUE = -1
 
     class _COORD(ctypes.Structure):
         _fields_ = [('X', ctypes.c_short),
                     ('Y', ctypes.c_short)]
 
     class _SMALL_RECT(ctypes.Structure):
         _fields_ = [('Left', ctypes.c_short),
                     ('Top', ctypes.c_short),
                     ('Right', ctypes.c_short),
                     ('Bottom', ctypes.c_short)]
 
     class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
         _fields_ = [('dwSize', _COORD),
                     ('dwCursorPosition', _COORD),
                     ('wAttributes', _WORD),
                     ('srWindow', _SMALL_RECT),
                     ('dwMaximumWindowSize', _COORD)]
 
     _STD_OUTPUT_HANDLE = 0xfffffff5L # (DWORD)-11
     _STD_ERROR_HANDLE = 0xfffffff4L  # (DWORD)-12
 
     _FOREGROUND_BLUE = 0x0001
     _FOREGROUND_GREEN = 0x0002
     _FOREGROUND_RED = 0x0004
     _FOREGROUND_INTENSITY = 0x0008
 
     _BACKGROUND_BLUE = 0x0010
     _BACKGROUND_GREEN = 0x0020
     _BACKGROUND_RED = 0x0040
     _BACKGROUND_INTENSITY = 0x0080
 
     _COMMON_LVB_REVERSE_VIDEO = 0x4000
     _COMMON_LVB_UNDERSCORE = 0x8000
 
     # http://msdn.microsoft.com/en-us/library/ms682088%28VS.85%29.aspx
     w32effects = {
         'none': -1,
         'black': 0,
         'red': _FOREGROUND_RED,
         'green': _FOREGROUND_GREEN,
         'yellow': _FOREGROUND_RED | _FOREGROUND_GREEN,
         'blue': _FOREGROUND_BLUE,
         'magenta': _FOREGROUND_BLUE | _FOREGROUND_RED,
         'cyan': _FOREGROUND_BLUE | _FOREGROUND_GREEN,
         'white': _FOREGROUND_RED | _FOREGROUND_GREEN | _FOREGROUND_BLUE,
         'bold': _FOREGROUND_INTENSITY,
         'black_background': 0x100,                  # unused value > 0x0f
         'red_background': _BACKGROUND_RED,
         'green_background': _BACKGROUND_GREEN,
         'yellow_background': _BACKGROUND_RED | _BACKGROUND_GREEN,
         'blue_background': _BACKGROUND_BLUE,
         'purple_background': _BACKGROUND_BLUE | _BACKGROUND_RED,
         'cyan_background': _BACKGROUND_BLUE | _BACKGROUND_GREEN,
         'white_background': (_BACKGROUND_RED | _BACKGROUND_GREEN |
                              _BACKGROUND_BLUE),
         'bold_background': _BACKGROUND_INTENSITY,
         'underline': _COMMON_LVB_UNDERSCORE,  # double-byte charsets only
         'inverse': _COMMON_LVB_REVERSE_VIDEO, # double-byte charsets only
     }
 
     passthrough = set([_FOREGROUND_INTENSITY,
                        _BACKGROUND_INTENSITY,
                        _COMMON_LVB_UNDERSCORE,
                        _COMMON_LVB_REVERSE_VIDEO])
 
     stdout = _kernel32.GetStdHandle(
                   _STD_OUTPUT_HANDLE)  # don't close the handle returned
     if stdout is None or stdout == _INVALID_HANDLE_VALUE:
         w32effects = None
     else:
         csbi = _CONSOLE_SCREEN_BUFFER_INFO()
         if not _kernel32.GetConsoleScreenBufferInfo(
                     stdout, ctypes.byref(csbi)):
             # stdout may not support GetConsoleScreenBufferInfo()
             # when called from subprocess or redirected
             w32effects = None
         else:
             origattr = csbi.wAttributes
             ansire = re.compile('\033\[([^m]*)m([^\033]*)(.*)',
                                 re.MULTILINE | re.DOTALL)
 
     def win32print(text, orig, **opts):
         label = opts.get('label', '')
         attr = origattr
 
         def mapcolor(val, attr):
             if val == -1:
                 return origattr
             elif val in passthrough:
                 return attr | val
             elif val > 0x0f:
                 return (val & 0x70) | (attr & 0x8f)
             else:
                 return (val & 0x07) | (attr & 0xf8)
 
         # determine console attributes based on labels
         for l in label.split():
             style = _styles.get(l, '')
             for effect in style.split():
                 attr = mapcolor(w32effects[effect], attr)
 
         # hack to ensure regexp finds data
         if not text.startswith('\033['):
             text = '\033[m' + text
 
         # Look for ANSI-like codes embedded in text
         m = re.match(ansire, text)
 
         try:
             while m:
                 for sattr in m.group(1).split(';'):
                     if sattr:
                         attr = mapcolor(int(sattr), attr)
                 _kernel32.SetConsoleTextAttribute(stdout, attr)
                 orig(m.group(2), **opts)
                 m = re.match(ansire, m.group(3))
         finally:
             # Explicity reset original attributes
             _kernel32.SetConsoleTextAttribute(stdout, origattr)

hgext/convert/darcs.py

@@ -1,200 +1,200
 # darcs.py - darcs support for the convert extension
 #
 #  Copyright 2007-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from common import NoRepo, checktool, commandline, commit, converter_source
 from mercurial.i18n import _
-from mercurial import encoding, util
+from mercurial import util
 import os, shutil, tempfile, re
 
 # The naming drift of ElementTree is fun!
 
 try:
     from xml.etree.cElementTree import ElementTree, XMLParser
 except ImportError:
     try:
         from xml.etree.ElementTree import ElementTree, XMLParser
     except ImportError:
         try:
             from elementtree.cElementTree import ElementTree, XMLParser
         except ImportError:
             try:
                 from elementtree.ElementTree import ElementTree, XMLParser
             except ImportError:
                 ElementTree = None
 
 class darcs_source(converter_source, commandline):
     def __init__(self, ui, path, rev=None):
         converter_source.__init__(self, ui, path, rev=rev)
         commandline.__init__(self, ui, 'darcs')
 
         # check for _darcs, ElementTree so that we can easily skip
         # test-convert-darcs if ElementTree is not around
         if not os.path.exists(os.path.join(path, '_darcs')):
             raise NoRepo(_("%s does not look like a darcs repository") % path)
 
         checktool('darcs')
         version = self.run0('--version').splitlines()[0].strip()
         if version < '2.1':
             raise util.Abort(_('darcs version 2.1 or newer needed (found %r)') %
                              version)
 
         if ElementTree is None:
             raise util.Abort(_("Python ElementTree module is not available"))
 
         self.path = os.path.realpath(path)
 
         self.lastrev = None
         self.changes = {}
         self.parents = {}
         self.tags = {}
 
         # Check darcs repository format
         format = self.format()
         if format:
             if format in ('darcs-1.0', 'hashed'):
                 raise NoRepo(_("%s repository format is unsupported, "
                                "please upgrade") % format)
         else:
             self.ui.warn(_('failed to detect repository format!'))
 
     def before(self):
         self.tmppath = tempfile.mkdtemp(
             prefix='convert-' + os.path.basename(self.path) + '-')
         output, status = self.run('init', repodir=self.tmppath)
         self.checkexit(status)
 
         tree = self.xml('changes', xml_output=True, summary=True,
                         repodir=self.path)
         tagname = None
         child = None
         for elt in tree.findall('patch'):
             node = elt.get('hash')
             name = elt.findtext('name', '')
             if name.startswith('TAG '):
                 tagname = name[4:].strip()
             elif tagname is not None:
                 self.tags[tagname] = node
                 tagname = None
             self.changes[node] = elt
             self.parents[child] = [node]
             child = node
         self.parents[child] = []
 
     def after(self):
         self.ui.debug('cleaning up %s\n' % self.tmppath)
         shutil.rmtree(self.tmppath, ignore_errors=True)
 
     def recode(self, s, encoding=None):
         if isinstance(s, unicode):
             # XMLParser returns unicode objects for anything it can't
             # encode into ASCII. We convert them back to str to get
             # recode's normal conversion behavior.
             s = s.encode('latin-1')
         return super(darcs_source, self).recode(s, encoding)
 
     def xml(self, cmd, **kwargs):
         # NOTE: darcs is currently encoding agnostic and will print
         # patch metadata byte-for-byte, even in the XML changelog.
         etree = ElementTree()
         # While we are decoding the XML as latin-1 to be as liberal as
         # possible, etree will still raise an exception if any
         # non-printable characters are in the XML changelog.
         parser = XMLParser(encoding='latin-1')
         fp = self._run(cmd, **kwargs)
         etree.parse(fp, parser=parser)
         self.checkexit(fp.close())
         return etree.getroot()
 
     def format(self):
         output, status = self.run('show', 'repo', no_files=True,
                                   repodir=self.path)
         self.checkexit(status)
         m = re.search(r'^\s*Format:\s*(.*)$', output, re.MULTILINE)
         if not m:
             return None
         return ','.join(sorted(f.strip() for f in m.group(1).split(',')))
 
     def manifest(self):
         man = []
         output, status = self.run('show', 'files', no_directories=True,
                                   repodir=self.tmppath)
         self.checkexit(status)
         for line in output.split('\n'):
             path = line[2:]
             if path:
                 man.append(path)
         return man
 
     def getheads(self):
         return self.parents[None]
 
     def getcommit(self, rev):
         elt = self.changes[rev]
         date = util.strdate(elt.get('local_date'), '%a %b %d %H:%M:%S %Z %Y')
         desc = elt.findtext('name') + '\n' + elt.findtext('comment', '')
         # etree can return unicode objects for name, comment, and author,
         # so recode() is used to ensure str objects are emitted.
         return commit(author=self.recode(elt.get('author')),
                       date=util.datestr(date),
                       desc=self.recode(desc).strip(),
                       parents=self.parents[rev])
 
     def pull(self, rev):
         output, status = self.run('pull', self.path, all=True,
                                   match='hash %s' % rev,
                                   no_test=True, no_posthook=True,
                                   external_merge='/bin/false',
                                   repodir=self.tmppath)
         if status:
             if output.find('We have conflicts in') == -1:
                 self.checkexit(status, output)
             output, status = self.run('revert', all=True, repodir=self.tmppath)
             self.checkexit(status, output)
 
     def getchanges(self, rev):
         copies = {}
         changes = []
         man = None
         for elt in self.changes[rev].find('summary').getchildren():
             if elt.tag in ('add_directory', 'remove_directory'):
                 continue
             if elt.tag == 'move':
                 if man is None:
                     man = self.manifest()
                 source, dest = elt.get('from'), elt.get('to')
                 if source in man:
                     # File move
                     changes.append((source, rev))
                     changes.append((dest, rev))
                     copies[dest] = source
                 else:
                     # Directory move, deduce file moves from manifest
                     source = source + '/'
                     for f in man:
                         if not f.startswith(source):
                             continue
                         fdest = dest + '/' + f[len(source):]
                         changes.append((f, rev))
                         changes.append((fdest, rev))
                         copies[fdest] = f
             else:
                 changes.append((elt.text.strip(), rev))
         self.pull(rev)
         self.lastrev = rev
         return sorted(changes), copies
 
     def getfile(self, name, rev):
         if rev != self.lastrev:
             raise util.Abort(_('internal calling inconsistency'))
         path = os.path.join(self.tmppath, name)
         data = open(path, 'rb').read()
         mode = os.lstat(path).st_mode
         mode = (mode & 0111) and 'x' or ''
         return data, mode
 
     def gettags(self):
         return self.tags

hgext/graphlog.py

@@ -1,399 +1,399
 # ASCII graph log extension for Mercurial
 #
 # Copyright 2007 Joel Rosdahl <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''command to view revision graphs from a shell
 
 This extension adds a --graph option to the incoming, outgoing and log
 commands. When this options is given, an ASCII representation of the
 revision graph is also shown.
 '''
 
 from mercurial.cmdutil import revrange, show_changeset
 from mercurial.commands import templateopts
 from mercurial.i18n import _
 from mercurial.node import nullrev
 from mercurial import cmdutil, commands, extensions
-from mercurial import hg, scmutil, util, graphmod
+from mercurial import hg, util, graphmod
 
 ASCIIDATA = 'ASC'
 
 def asciiedges(type, char, lines, seen, rev, parents):
     """adds edge info to changelog DAG walk suitable for ascii()"""
     if rev not in seen:
         seen.append(rev)
     nodeidx = seen.index(rev)
 
     knownparents = []
     newparents = []
     for parent in parents:
         if parent in seen:
             knownparents.append(parent)
         else:
             newparents.append(parent)
 
     ncols = len(seen)
     nextseen = seen[:]
     nextseen[nodeidx:nodeidx + 1] = newparents
     edges = [(nodeidx, nextseen.index(p)) for p in knownparents]
 
     while len(newparents) > 2:
         # ascii() only knows how to add or remove a single column between two
         # calls. Nodes with more than two parents break this constraint so we
         # introduce intermediate expansion lines to grow the active node list
         # slowly.
         edges.append((nodeidx, nodeidx))
         edges.append((nodeidx, nodeidx + 1))
         nmorecols = 1
         yield (type, char, lines, (nodeidx, edges, ncols, nmorecols))
         char = '\\'
         lines = []
         nodeidx += 1
         ncols += 1
         edges = []
         del newparents[0]
 
     if len(newparents) > 0:
         edges.append((nodeidx, nodeidx))
     if len(newparents) > 1:
         edges.append((nodeidx, nodeidx + 1))
     nmorecols = len(nextseen) - ncols
     seen[:] = nextseen
     yield (type, char, lines, (nodeidx, edges, ncols, nmorecols))
 
 def fix_long_right_edges(edges):
     for (i, (start, end)) in enumerate(edges):
         if end > start:
             edges[i] = (start, end + 1)
 
 def get_nodeline_edges_tail(
         node_index, p_node_index, n_columns, n_columns_diff, p_diff, fix_tail):
     if fix_tail and n_columns_diff == p_diff and n_columns_diff != 0:
         # Still going in the same non-vertical direction.
         if n_columns_diff == -1:
             start = max(node_index + 1, p_node_index)
             tail = ["|", " "] * (start - node_index - 1)
             tail.extend(["/", " "] * (n_columns - start))
             return tail
         else:
             return ["\\", " "] * (n_columns - node_index - 1)
     else:
         return ["|", " "] * (n_columns - node_index - 1)
 
 def draw_edges(edges, nodeline, interline):
     for (start, end) in edges:
         if start == end + 1:
             interline[2 * end + 1] = "/"
         elif start == end - 1:
             interline[2 * start + 1] = "\\"
         elif start == end:
             interline[2 * start] = "|"
         else:
             nodeline[2 * end] = "+"
             if start > end:
                 (start, end) = (end, start)
             for i in range(2 * start + 1, 2 * end):
                 if nodeline[i] != "+":
                     nodeline[i] = "-"
 
 def get_padding_line(ni, n_columns, edges):
     line = []
     line.extend(["|", " "] * ni)
     if (ni, ni - 1) in edges or (ni, ni) in edges:
         # (ni, ni - 1)      (ni, ni)
         # | | | |           | | | |
         # +---o |           | o---+
         # | | c |           | c | |
         # | |/ /            | |/ /
         # | | |             | | |
         c = "|"
     else:
         c = " "
     line.extend([c, " "])
     line.extend(["|", " "] * (n_columns - ni - 1))
     return line
 
 def asciistate():
     """returns the initial value for the "state" argument to ascii()"""
     return [0, 0]
 
 def ascii(ui, state, type, char, text, coldata):
     """prints an ASCII graph of the DAG
 
     takes the following arguments (one call per node in the graph):
 
       - ui to write to
       - Somewhere to keep the needed state in (init to asciistate())
       - Column of the current node in the set of ongoing edges.
       - Type indicator of node data == ASCIIDATA.
       - Payload: (char, lines):
         - Character to use as node's symbol.
         - List of lines to display as the node's text.
       - Edges; a list of (col, next_col) indicating the edges between
         the current node and its parents.
       - Number of columns (ongoing edges) in the current revision.
       - The difference between the number of columns (ongoing edges)
         in the next revision and the number of columns (ongoing edges)
         in the current revision. That is: -1 means one column removed;
         0 means no columns added or removed; 1 means one column added.
     """
 
     idx, edges, ncols, coldiff = coldata
     assert -2 < coldiff < 2
     if coldiff == -1:
         # Transform
         #
         #     | | |        | | |
         #     o | |  into  o---+
         #     |X /         |/ /
         #     | |          | |
         fix_long_right_edges(edges)
 
     # add_padding_line says whether to rewrite
     #
     #     | | | |        | | | |
     #     | o---+  into  | o---+
     #     |  / /         |   | |  # <--- padding line
     #     o | |          |  / /
     #                    o | |
     add_padding_line = (len(text) > 2 and coldiff == -1 and
                         [x for (x, y) in edges if x + 1 < y])
 
     # fix_nodeline_tail says whether to rewrite
     #
     #     | | o | |        | | o | |
     #     | | |/ /         | | |/ /
     #     | o | |    into  | o / /   # <--- fixed nodeline tail
     #     | |/ /           | |/ /
     #     o | |            o | |
     fix_nodeline_tail = len(text) <= 2 and not add_padding_line
 
     # nodeline is the line containing the node character (typically o)
     nodeline = ["|", " "] * idx
     nodeline.extend([char, " "])
 
     nodeline.extend(
         get_nodeline_edges_tail(idx, state[1], ncols, coldiff,
                                 state[0], fix_nodeline_tail))
 
     # shift_interline is the line containing the non-vertical
     # edges between this entry and the next
     shift_interline = ["|", " "] * idx
     if coldiff == -1:
         n_spaces = 1
         edge_ch = "/"
     elif coldiff == 0:
         n_spaces = 2
         edge_ch = "|"
     else:
         n_spaces = 3
         edge_ch = "\\"
     shift_interline.extend(n_spaces * [" "])
     shift_interline.extend([edge_ch, " "] * (ncols - idx - 1))
 
     # draw edges from the current node to its parents
     draw_edges(edges, nodeline, shift_interline)
 
     # lines is the list of all graph lines to print
     lines = [nodeline]
     if add_padding_line:
         lines.append(get_padding_line(idx, ncols, edges))
     lines.append(shift_interline)
 
     # make sure that there are as many graph lines as there are
     # log strings
     while len(text) < len(lines):
         text.append("")
     if len(lines) < len(text):
         extra_interline = ["|", " "] * (ncols + coldiff)
         while len(lines) < len(text):
             lines.append(extra_interline)
 
     # print lines
     indentation_level = max(ncols, ncols + coldiff)
     for (line, logstr) in zip(lines, text):
         ln = "%-*s %s" % (2 * indentation_level, "".join(line), logstr)
         ui.write(ln.rstrip() + '\n')
 
     # ... and start over
     state[0] = coldiff
     state[1] = idx
 
 def get_revs(repo, rev_opt):
     if rev_opt:
         revs = revrange(repo, rev_opt)
         if len(revs) == 0:
             return (nullrev, nullrev)
         return (max(revs), min(revs))
     else:
         return (len(repo) - 1, 0)
 
 def check_unsupported_flags(pats, opts):
     for op in ["follow_first", "copies", "newest_first"]:
         if op in opts and opts[op]:
             raise util.Abort(_("-G/--graph option is incompatible with --%s")
                              % op.replace("_", "-"))
     if pats and opts.get('follow'):
         raise util.Abort(_("-G/--graph option is incompatible with --follow "
                            "with file argument"))
 
 def revset(pats, opts):
     """Return revset str built of revisions, log options and file patterns.
     """
     opt2revset = {
         'follow': (0, 'follow()'),
         'no_merges': (0, 'not merge()'),
         'only_merges': (0, 'merge()'),
         'removed': (0, 'removes("*")'),
         'date': (1, 'date($)'),
         'branch': (2, 'branch($)'),
         'exclude': (2, 'not file($)'),
         'include': (2, 'file($)'),
         'keyword': (2, 'keyword($)'),
         'only_branch': (2, 'branch($)'),
         'prune': (2, 'not ($ or ancestors($))'),
         'user': (2, 'user($)'),
         }
     optrevset = []
     revset = []
     for op, val in opts.iteritems():
         if not val:
             continue
         if op == 'rev':
             # Already a revset
             revset.extend(val)
         if op not in opt2revset:
             continue
         arity, revop = opt2revset[op]
         revop = revop.replace('$', '%(val)r')
         if arity == 0:
             optrevset.append(revop)
         elif arity == 1:
             optrevset.append(revop % {'val': val})
         else:
             for f in val:
                 optrevset.append(revop % {'val': f})
 
     for path in pats:
         optrevset.append('file(%r)' % path)
 
     if revset or optrevset:
         if revset:
             revset = ['(' + ' or '.join(revset) + ')']
         if optrevset:
             revset.append('(' + ' and '.join(optrevset) + ')')
         revset = ' and '.join(revset)
     else:
         revset = 'all()'
     return revset
 
 def generate(ui, dag, displayer, showparents, edgefn):
     seen, state = [], asciistate()
     for rev, type, ctx, parents in dag:
         char = ctx.node() in showparents and '@' or 'o'
         displayer.show(ctx)
         lines = displayer.hunk.pop(rev).split('\n')[:-1]
         displayer.flush(rev)
         edges = edgefn(type, char, lines, seen, rev, parents)
         for type, char, lines, coldata in edges:
             ascii(ui, state, type, char, lines, coldata)
     displayer.close()
 
 def graphlog(ui, repo, *pats, **opts):
     """show revision history alongside an ASCII revision graph
 
     Print a revision history alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
 
     check_unsupported_flags(pats, opts)
 
     revs = sorted(revrange(repo, [revset(pats, opts)]), reverse=1)
     limit = cmdutil.loglimit(opts)
     if limit is not None:
         revs = revs[:limit]
     revdag = graphmod.dagwalker(repo, revs)
 
     displayer = show_changeset(ui, repo, opts, buffered=True)
     showparents = [ctx.node() for ctx in repo[None].parents()]
     generate(ui, revdag, displayer, showparents, asciiedges)
 
 def graphrevs(repo, nodes, opts):
     limit = cmdutil.loglimit(opts)
     nodes.reverse()
     if limit is not None:
         nodes = nodes[:limit]
     return graphmod.nodes(repo, nodes)
 
 def goutgoing(ui, repo, dest=None, **opts):
     """show the outgoing changesets alongside an ASCII revision graph
 
     Print the outgoing changesets alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
 
     check_unsupported_flags([], opts)
     o = hg._outgoing(ui, repo, dest, opts)
     if o is None:
         return
 
     revdag = graphrevs(repo, o, opts)
     displayer = show_changeset(ui, repo, opts, buffered=True)
     showparents = [ctx.node() for ctx in repo[None].parents()]
     generate(ui, revdag, displayer, showparents, asciiedges)
 
 def gincoming(ui, repo, source="default", **opts):
     """show the incoming changesets alongside an ASCII revision graph
 
     Print the incoming changesets alongside a revision graph drawn with
     ASCII characters.
 
     Nodes printed as an @ character are parents of the working
     directory.
     """
     def subreporecurse():
         return 1
 
     check_unsupported_flags([], opts)
     def display(other, chlist, displayer):
         revdag = graphrevs(other, chlist, opts)
         showparents = [ctx.node() for ctx in repo[None].parents()]
         generate(ui, revdag, displayer, showparents, asciiedges)
 
     hg._incoming(display, subreporecurse, ui, repo, source, opts, buffered=True)
 
 def uisetup(ui):
     '''Initialize the extension.'''
     _wrapcmd(ui, 'log', commands.table, graphlog)
     _wrapcmd(ui, 'incoming', commands.table, gincoming)
     _wrapcmd(ui, 'outgoing', commands.table, goutgoing)
 
 def _wrapcmd(ui, cmd, table, wrapfn):
     '''wrap the command'''
     def graph(orig, *args, **kwargs):
         if kwargs['graph']:
             return wrapfn(*args, **kwargs)
         return orig(*args, **kwargs)
     entry = extensions.wrapcommand(table, cmd, graph)
     entry[1].append(('G', 'graph', None, _("show the revision DAG")))
 
 cmdtable = {
     "glog":
         (graphlog,
          [('l', 'limit', '',
            _('limit number of changes displayed'), _('NUM')),
           ('p', 'patch', False, _('show patch')),
           ('r', 'rev', [],
            _('show the specified revision or range'), _('REV')),
          ] + templateopts,
          _('hg glog [OPTION]... [FILE]')),
 }

hgext/progress.py

@@ -1,275 +1,274
 # progress.py show progress bars for some actions
 #
 # Copyright (C) 2010 Augie Fackler <[e-mail]>
 #
 # 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 (at your
 # option) 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.
 #
 # You should have received a copy of the GNU General Public License along
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 """show progress bars for some actions
 
 This extension uses the progress information logged by hg commands
 to draw progress bars that are as informative as possible. Some progress
 bars only offer indeterminate information, while others have a definite
 end point.
 
 The following settings are available::
 
   [progress]
   delay = 3 # number of seconds (float) before showing the progress bar
   refresh = 0.1 # time in seconds between refreshes of the progress bar
   format = topic bar number estimate # format of the progress bar
   width = <none> # if set, the maximum width of the progress information
                  # (that is, min(width, term width) will be used)
   clear-complete = True # clear the progress bar after it's done
   disable = False # if true, don't show a progress bar
   assume-tty = False # if true, ALWAYS show a progress bar, unless
                      # disable is given
 
 Valid entries for the format field are topic, bar, number, unit,
 estimate, and item. item defaults to the last 20 characters of the
 item, but this can be changed by adding either ``-<num>`` which would
 take the last num characters, or ``+<num>`` for the first num
 characters.
 """
 
 import sys
 import time
 
 from mercurial.i18n import _
-from mercurial import util
 
 def spacejoin(*args):
     return ' '.join(s for s in args if s)
 
 def shouldprint(ui):
     return (getattr(sys.stderr, 'isatty', None) and
             (sys.stderr.isatty() or ui.configbool('progress', 'assume-tty')))
 
 def fmtremaining(seconds):
     if seconds < 60:
         # i18n: format XX seconds as "XXs"
         return _("%02ds") % (seconds)
     minutes = seconds // 60
     if minutes < 60:
         seconds -= minutes * 60
         # i18n: format X minutes and YY seconds as "XmYYs"
         return _("%dm%02ds") % (minutes, seconds)
     # we're going to ignore seconds in this case
     minutes += 1
     hours = minutes // 60
     minutes -= hours * 60
     if hours < 30:
         # i18n: format X hours and YY minutes as "XhYYm"
         return _("%dh%02dm") % (hours, minutes)
     # we're going to ignore minutes in this case
     hours += 1
     days = hours // 24
     hours -= days * 24
     if days < 15:
         # i18n: format X days and YY hours as "XdYYh"
         return _("%dd%02dh") % (days, hours)
     # we're going to ignore hours in this case
     days += 1
     weeks = days // 7
     days -= weeks * 7
     if weeks < 55:
         # i18n: format X weeks and YY days as "XwYYd"
         return _("%dw%02dd") % (weeks, days)
     # we're going to ignore days and treat a year as 52 weeks
     weeks += 1
     years = weeks // 52
     weeks -= years * 52
     # i18n: format X years and YY weeks as "XyYYw"
     return _("%dy%02dw") % (years, weeks)
 
 class progbar(object):
     def __init__(self, ui):
         self.ui = ui
         self.resetstate()
 
     def resetstate(self):
         self.topics = []
         self.topicstates = {}
         self.starttimes = {}
         self.startvals = {}
         self.printed = False
         self.lastprint = time.time() + float(self.ui.config(
             'progress', 'delay', default=3))
         self.indetcount = 0
         self.refresh = float(self.ui.config(
             'progress', 'refresh', default=0.1))
         self.order = self.ui.configlist(
             'progress', 'format',
             default=['topic', 'bar', 'number', 'estimate'])
 
     def show(self, now, topic, pos, item, unit, total):
         if not shouldprint(self.ui):
             return
         termwidth = self.width()
         self.printed = True
         head = ''
         needprogress = False
         tail = ''
         for indicator in self.order:
             add = ''
             if indicator == 'topic':
                 add = topic
             elif indicator == 'number':
                 if total:
                     add = ('% ' + str(len(str(total))) +
                            's/%s') % (pos, total)
                 else:
                     add = str(pos)
             elif indicator.startswith('item') and item:
                 slice = 'end'
                 if '-' in indicator:
                     wid = int(indicator.split('-')[1])
                 elif '+' in indicator:
                     slice = 'beginning'
                     wid = int(indicator.split('+')[1])
                 else:
                     wid = 20
                 if slice == 'end':
                     add = item[-wid:]
                 else:
                     add = item[:wid]
                 add += (wid - len(add)) * ' '
             elif indicator == 'bar':
                 add = ''
                 needprogress = True
             elif indicator == 'unit' and unit:
                 add = unit
             elif indicator == 'estimate':
                 add = self.estimate(topic, pos, total, now)
             if not needprogress:
                 head = spacejoin(head, add)
             else:
                 tail = spacejoin(tail, add)
         if needprogress:
             used = 0
             if head:
                 used += len(head) + 1
             if tail:
                 used += len(tail) + 1
             progwidth = termwidth - used - 3
             if total and pos <= total:
                 amt = pos * progwidth // total
                 bar = '=' * (amt - 1)
                 if amt > 0:
                     bar += '>'
                 bar += ' ' * (progwidth - amt)
             else:
                 progwidth -= 3
                 self.indetcount += 1
                 # mod the count by twice the width so we can make the
                 # cursor bounce between the right and left sides
                 amt = self.indetcount % (2 * progwidth)
                 amt -= progwidth
                 bar = (' ' * int(progwidth - abs(amt)) + '<=>' +
                        ' ' * int(abs(amt)))
             prog = ''.join(('[', bar , ']'))
             out = spacejoin(head, prog, tail)
         else:
             out = spacejoin(head, tail)
         sys.stderr.write('\r' + out[:termwidth])
         sys.stderr.flush()
 
     def clear(self):
         if not shouldprint(self.ui):
             return
         sys.stderr.write('\r%s\r' % (' ' * self.width()))
 
     def complete(self):
         if not shouldprint(self.ui):
             return
         if self.ui.configbool('progress', 'clear-complete', default=True):
             self.clear()
         else:
             sys.stderr.write('\n')
         sys.stderr.flush()
 
     def width(self):
         tw = self.ui.termwidth()
         return min(int(self.ui.config('progress', 'width', default=tw)), tw)
 
     def estimate(self, topic, pos, total, now):
         if total is None:
             return ''
         initialpos = self.startvals[topic]
         target = total - initialpos
         delta = pos - initialpos
         if delta > 0:
             elapsed = now - self.starttimes[topic]
             if elapsed > float(
                 self.ui.config('progress', 'estimate', default=2)):
                 seconds = (elapsed * (target - delta)) // delta + 1
                 return fmtremaining(seconds)
         return ''
 
     def progress(self, topic, pos, item='', unit='', total=None):
         now = time.time()
         if pos is None:
             self.starttimes.pop(topic, None)
             self.startvals.pop(topic, None)
             self.topicstates.pop(topic, None)
             # reset the progress bar if this is the outermost topic
             if self.topics and self.topics[0] == topic and self.printed:
                 self.complete()
                 self.resetstate()
             # truncate the list of topics assuming all topics within
             # this one are also closed
             if topic in self.topics:
               self.topics = self.topics[:self.topics.index(topic)]
         else:
             if topic not in self.topics:
                 self.starttimes[topic] = now
                 self.startvals[topic] = pos
                 self.topics.append(topic)
             self.topicstates[topic] = pos, item, unit, total
             if now - self.lastprint >= self.refresh and self.topics:
                 self.lastprint = now
                 current = self.topics[-1]
                 self.show(now, topic, *self.topicstates[topic])
 
 def uisetup(ui):
     class progressui(ui.__class__):
         _progbar = None
 
         def progress(self, *args, **opts):
             self._progbar.progress(*args, **opts)
             return super(progressui, self).progress(*args, **opts)
 
         def write(self, *args, **opts):
             if self._progbar.printed:
                 self._progbar.clear()
             return super(progressui, self).write(*args, **opts)
 
         def write_err(self, *args, **opts):
             if self._progbar.printed:
                 self._progbar.clear()
             return super(progressui, self).write_err(*args, **opts)
 
     # Apps that derive a class from ui.ui() can use
     # setconfig('progress', 'disable', 'True') to disable this extension
     if ui.configbool('progress', 'disable'):
         return
     if shouldprint(ui) and not ui.debugflag and not ui.quiet:
         ui.__class__ = progressui
         # we instantiate one globally shared progress bar to avoid
         # competing progress bars when multiple UI objects get created
         if not progressui._progbar:
             progressui._progbar = progbar(ui)
 
 def reposetup(ui, repo):
     uisetup(repo.ui)