libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/logilab/common/__pkginfo__.py

@@ -1,57 +0,0 @@
-# copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 2.1 of the License, or (at your option) any
-# later version.
-#
-# logilab-common 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 Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""logilab.common packaging information"""
-__docformat__ = "restructuredtext en"
-import sys
-import os
-
-distname = 'logilab-common'
-modname = 'common'
-subpackage_of = 'logilab'
-subpackage_master = True
-
-numversion = (0, 63, 2)
-version = '.'.join([str(num) for num in numversion])
-
-license = 'LGPL' # 2.1 or later
-description = "collection of low-level Python packages and modules used by Logilab projects"
-web = "http://www.logilab.org/project/%s" % distname
-mailinglist = "mailto://python-projects@lists.logilab.org"
-author = "Logilab"
-author_email = "contact@logilab.fr"
-
-
-from os.path import join
-scripts = [join('bin', 'pytest')]
-include_dirs = [join('test', 'data')]
-
-install_requires = [
-        'six >= 1.4.0',
-        ]
-test_require = ['pytz']
-
-if sys.version_info < (2, 7):
-    install_requires.append('unittest2 >= 0.5.1')
-if os.name == 'nt':
-    install_requires.append('colorama')
-
-classifiers = ["Topic :: Utilities",
-               "Programming Language :: Python",
-               "Programming Language :: Python :: 2",
-               "Programming Language :: Python :: 3",
-               ]

data/vendor/depot_tools/third_party/logilab/common/cache.py

@@ -1,114 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 2.1 of the License, or (at your option) any
-# later version.
-#
-# logilab-common 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 Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Cache module, with a least recently used algorithm for the management of the
-deletion of entries.
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-from threading import Lock
-
-from logilab.common.decorators import locked
-
-_marker = object()
-
-class Cache(dict):
-    """A dictionary like cache.
-
-    inv:
-        len(self._usage) <= self.size
-        len(self.data) <= self.size
-    """
-
-    def __init__(self, size=100):
-        """ Warning : Cache.__init__() != dict.__init__().
-        Constructor does not take any arguments beside size.
-        """
-        assert size >= 0, 'cache size must be >= 0 (0 meaning no caching)'
-        self.size = size
-        self._usage = []
-        self._lock = Lock()
-        super(Cache, self).__init__()
-
-    def _acquire(self):
-        self._lock.acquire()
-
-    def _release(self):
-        self._lock.release()
-
-    def _update_usage(self, key):
-        if not self._usage:
-            self._usage.append(key)
-        elif self._usage[-1] != key:
-            try:
-                self._usage.remove(key)
-            except ValueError:
-                # we are inserting a new key
-                # check the size of the dictionary
-                # and remove the oldest item in the cache
-                if self.size and len(self._usage) >= self.size:
-                    super(Cache, self).__delitem__(self._usage[0])
-                    del self._usage[0]
-            self._usage.append(key)
-        else:
-            pass # key is already the most recently used key
-
-    def __getitem__(self, key):
-        value = super(Cache, self).__getitem__(key)
-        self._update_usage(key)
-        return value
-    __getitem__ = locked(_acquire, _release)(__getitem__)
-
-    def __setitem__(self, key, item):
-        # Just make sure that size > 0 before inserting a new item in the cache
-        if self.size > 0:
-            super(Cache, self).__setitem__(key, item)
-            self._update_usage(key)
-    __setitem__ = locked(_acquire, _release)(__setitem__)
-
-    def __delitem__(self, key):
-        super(Cache, self).__delitem__(key)
-        self._usage.remove(key)
-    __delitem__ = locked(_acquire, _release)(__delitem__)
-
-    def clear(self):
-        super(Cache, self).clear()
-        self._usage = []
-    clear = locked(_acquire, _release)(clear)
-
-    def pop(self, key, default=_marker):
-        if key in self:
-            self._usage.remove(key)
-        #if default is _marker:
-        #    return super(Cache, self).pop(key)
-        return super(Cache, self).pop(key, default)
-    pop = locked(_acquire, _release)(pop)
-
-    def popitem(self):
-        raise NotImplementedError()
-
-    def setdefault(self, key, default=None):
-        raise NotImplementedError()
-
-    def update(self, other):
-        raise NotImplementedError()
-
-

data/vendor/depot_tools/third_party/logilab/common/changelog.py

@@ -1,238 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 2.1 of the License, or (at your option) any
-# later version.
-#
-# logilab-common 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 Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Manipulation of upstream change log files.
-
-The upstream change log files format handled is simpler than the one
-often used such as those generated by the default Emacs changelog mode.
-
-Sample ChangeLog format::
-
-  Change log for project Yoo
-  ==========================
-
-   --
-      * add a new functionality
-
-  2002-02-01 -- 0.1.1
-      * fix bug #435454
-      * fix bug #434356
-
-  2002-01-01 -- 0.1
-      * initial release
-
-
-There is 3 entries in this change log, one for each released version and one
-for the next version (i.e. the current entry).
-Each entry contains a set of messages corresponding to changes done in this
-release.
-All the non empty lines before the first entry are considered as the change
-log title.
-"""
-
-__docformat__ = "restructuredtext en"
-
-import sys
-from stat import S_IWRITE
-
-from six import string_types
-
-BULLET = '*'
-SUBBULLET = '-'
-INDENT = ' ' * 4
-
-class NoEntry(Exception):
-    """raised when we are unable to find an entry"""
-
-class EntryNotFound(Exception):
-    """raised when we are unable to find a given entry"""
-
-class Version(tuple):
-    """simple class to handle soft version number has a tuple while
-    correctly printing it as X.Y.Z
-    """
-    def __new__(cls, versionstr):
-        if isinstance(versionstr, string_types):
-            versionstr = versionstr.strip(' :') # XXX (syt) duh?
-            parsed = cls.parse(versionstr)
-        else:
-            parsed = versionstr
-        return tuple.__new__(cls, parsed)
-
-    @classmethod
-    def parse(cls, versionstr):
-        versionstr = versionstr.strip(' :')
-        try:
-            return [int(i) for i in versionstr.split('.')]
-        except ValueError as ex:
-            raise ValueError("invalid literal for version '%s' (%s)"%(versionstr, ex))
-
-    def __str__(self):
-        return '.'.join([str(i) for i in self])
-
-# upstream change log #########################################################
-
-class ChangeLogEntry(object):
-    """a change log entry, i.e. a set of messages associated to a version and
-    its release date
-    """
-    version_class = Version
-
-    def __init__(self, date=None, version=None, **kwargs):
-        self.__dict__.update(kwargs)
-        if version:
-            self.version = self.version_class(version)
-        else:
-            self.version = None
-        self.date = date
-        self.messages = []
-
-    def add_message(self, msg):
-        """add a new message"""
-        self.messages.append(([msg], []))
-
-    def complete_latest_message(self, msg_suite):
-        """complete the latest added message
-        """
-        if not self.messages:
-            raise ValueError('unable to complete last message as there is no previous message)')
-        if self.messages[-1][1]: # sub messages
-            self.messages[-1][1][-1].append(msg_suite)
-        else: # message
-            self.messages[-1][0].append(msg_suite)
-
-    def add_sub_message(self, sub_msg, key=None):
-        if not self.messages:
-            raise ValueError('unable to complete last message as there is no previous message)')
-        if key is None:
-            self.messages[-1][1].append([sub_msg])
-        else:
-            raise NotImplementedError("sub message to specific key are not implemented yet")
-
-    def write(self, stream=sys.stdout):
-        """write the entry to file """
-        stream.write('%s  --  %s\n' % (self.date or '', self.version or ''))
-        for msg, sub_msgs in self.messages:
-            stream.write('%s%s %s\n' % (INDENT, BULLET, msg[0]))
-            stream.write(''.join(msg[1:]))
-            if sub_msgs:
-                stream.write('\n')
-            for sub_msg in sub_msgs:
-                stream.write('%s%s %s\n' % (INDENT * 2, SUBBULLET, sub_msg[0]))
-                stream.write(''.join(sub_msg[1:]))
-            stream.write('\n')
-
-        stream.write('\n\n')
-
-class ChangeLog(object):
-    """object representation of a whole ChangeLog file"""
-
-    entry_class = ChangeLogEntry
-
-    def __init__(self, changelog_file, title=''):
-        self.file = changelog_file
-        self.title = title
-        self.additional_content = ''
-        self.entries = []
-        self.load()
-
-    def __repr__(self):
-        return '<ChangeLog %s at %s (%s entries)>' % (self.file, id(self),
-                                                      len(self.entries))
-
-    def add_entry(self, entry):
-        """add a new entry to the change log"""
-        self.entries.append(entry)
-
-    def get_entry(self, version='', create=None):
-        """ return a given changelog entry
-        if version is omitted, return the current entry
-        """
-        if not self.entries:
-            if version or not create:
-                raise NoEntry()
-            self.entries.append(self.entry_class())
-        if not version:
-            if self.entries[0].version and create is not None:
-                self.entries.insert(0, self.entry_class())
-            return self.entries[0]
-        version = self.version_class(version)
-        for entry in self.entries:
-            if entry.version == version:
-                return entry
-        raise EntryNotFound()
-
-    def add(self, msg, create=None):
-        """add a new message to the latest opened entry"""
-        entry = self.get_entry(create=create)
-        entry.add_message(msg)
-
-    def load(self):
-        """ read a logilab's ChangeLog from file """
-        try:
-            stream = open(self.file)
-        except IOError:
-            return
-        last = None
-        expect_sub = False
-        for line in stream.readlines():
-            sline = line.strip()
-            words = sline.split()
-            # if new entry
-            if len(words) == 1 and words[0] == '--':
-                expect_sub = False
-                last = self.entry_class()
-                self.add_entry(last)
-            # if old entry
-            elif len(words) == 3 and words[1] == '--':
-                expect_sub = False
-                last = self.entry_class(words[0], words[2])
-                self.add_entry(last)
-            # if title
-            elif sline and last is None:
-                self.title = '%s%s' % (self.title, line)
-            # if new entry
-            elif sline and sline[0] == BULLET:
-                expect_sub = False
-                last.add_message(sline[1:].strip())
-            # if new sub_entry
-            elif expect_sub and sline and sline[0] == SUBBULLET:
-                last.add_sub_message(sline[1:].strip())
-            # if new line for current entry
-            elif sline and last.messages:
-                last.complete_latest_message(line)
-            else:
-                expect_sub = True
-                self.additional_content += line
-        stream.close()
-
-    def format_title(self):
-        return '%s\n\n' % self.title.strip()
-
-    def save(self):
-        """write back change log"""
-        # filetutils isn't importable in appengine, so import locally
-        from logilab.common.fileutils import ensure_fs_mode
-        ensure_fs_mode(self.file, S_IWRITE)
-        self.write(open(self.file, 'w'))
-
-    def write(self, stream=sys.stdout):
-        """write changelog to stream"""
-        stream.write(self.format_title())
-        for entry in self.entries:
-            entry.write(stream)
-

data/vendor/depot_tools/third_party/logilab/common/clcommands.py

@@ -1,334 +0,0 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# This file is part of logilab-common.
-#
-# logilab-common is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation, either version 2.1 of the License, or (at your option) any
-# later version.
-#
-# logilab-common 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 Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
-"""Helper functions to support command line tools providing more than
-one command.
-
-e.g called as "tool command [options] args..." where <options> and <args> are
-command'specific
-"""
-
-from __future__ import print_function
-
-__docformat__ = "restructuredtext en"
-
-import sys
-import logging
-from os.path import basename
-
-from logilab.common.configuration import Configuration
-from logilab.common.logging_ext import init_log, get_threshold
-from logilab.common.deprecation import deprecated
-
-
-class BadCommandUsage(Exception):
-    """Raised when an unknown command is used or when a command is not
-    correctly used (bad options, too much / missing arguments...).
-
-    Trigger display of command usage.
-    """
-
-class CommandError(Exception):
-    """Raised when a command can't be processed and we want to display it and
-    exit, without traceback nor usage displayed.
-    """
-
-
-# command line access point ####################################################
-
-class CommandLine(dict):
-    """Usage:
-
-    >>> LDI = cli.CommandLine('ldi', doc='Logilab debian installer',
-                              version=version, rcfile=RCFILE)
-    >>> LDI.register(MyCommandClass)
-    >>> LDI.register(MyOtherCommandClass)
-    >>> LDI.run(sys.argv[1:])
-
-    Arguments:
-
-    * `pgm`, the program name, default to `basename(sys.argv[0])`
-
-    * `doc`, a short description of the command line tool
-
-    * `copyright`, additional doc string that will be appended to the generated
-      doc
-
-    * `version`, version number of string of the tool. If specified, global
-      --version option will be available.
-
-    * `rcfile`, path to a configuration file. If specified, global --C/--rc-file
-      option will be available?  self.rcfile = rcfile
-
-    * `logger`, logger to propagate to commands, default to
-      `logging.getLogger(self.pgm))`
-    """
-    def __init__(self, pgm=None, doc=None, copyright=None, version=None,
-                 rcfile=None, logthreshold=logging.ERROR,
-                 check_duplicated_command=True):
-        if pgm is None:
-            pgm = basename(sys.argv[0])
-        self.pgm = pgm
-        self.doc = doc
-        self.copyright = copyright
-        self.version = version
-        self.rcfile = rcfile
-        self.logger = None
-        self.logthreshold = logthreshold
-        self.check_duplicated_command = check_duplicated_command
-
-    def register(self, cls, force=False):
-        """register the given :class:`Command` subclass"""
-        assert not self.check_duplicated_command or force or not cls.name in self, \
-               'a command %s is already defined' % cls.name
-        self[cls.name] = cls
-        return cls
-
-    def run(self, args):
-        """main command line access point:
-        * init logging
-        * handle global options (-h/--help, --version, -C/--rc-file)
-        * check command
-        * run command
-
-        Terminate by :exc:`SystemExit`
-        """
-        init_log(debug=True, # so that we use StreamHandler
-                 logthreshold=self.logthreshold,
-                 logformat='%(levelname)s: %(message)s')
-        try:
-            arg = args.pop(0)
-        except IndexError:
-            self.usage_and_exit(1)
-        if arg in ('-h', '--help'):
-            self.usage_and_exit(0)
-        if self.version is not None and arg in ('--version'):
-            print(self.version)
-            sys.exit(0)
-        rcfile = self.rcfile
-        if rcfile is not None and arg in ('-C', '--rc-file'):
-            try:
-                rcfile = args.pop(0)
-                arg = args.pop(0)
-            except IndexError:
-                self.usage_and_exit(1)
-        try:
-            command = self.get_command(arg)
-        except KeyError:
-            print('ERROR: no %s command' % arg)
-            print()
-            self.usage_and_exit(1)
-        try:
-            sys.exit(command.main_run(args, rcfile))
-        except KeyboardInterrupt as exc:
-            print('Interrupted', end=' ')
-            if str(exc):
-                print(': %s' % exc, end=' ')
-            print()
-            sys.exit(4)
-        except BadCommandUsage as err:
-            print('ERROR:', err)
-            print()
-            print(command.help())
-            sys.exit(1)
-
-    def create_logger(self, handler, logthreshold=None):
-        logger = logging.Logger(self.pgm)
-        logger.handlers = [handler]
-        if logthreshold is None:
-            logthreshold = get_threshold(self.logthreshold)
-        logger.setLevel(logthreshold)
-        return logger
-
-    def get_command(self, cmd, logger=None):
-        if logger is None:
-            logger = self.logger
-        if logger is None:
-            logger = self.logger = logging.getLogger(self.pgm)
-            logger.setLevel(get_threshold(self.logthreshold))
-        return self[cmd](logger)
-
-    def usage(self):
-        """display usage for the main program (i.e. when no command supplied)
-        and exit
-        """
-        print('usage:', self.pgm, end=' ')
-        if self.rcfile:
-            print('[--rc-file=<configuration file>]', end=' ')
-        print('<command> [options] <command argument>...')
-        if self.doc:
-            print('\n%s' % self.doc)
-        print('''
-Type "%(pgm)s <command> --help" for more information about a specific
-command. Available commands are :\n''' % self.__dict__)
-        max_len = max([len(cmd) for cmd in self])
-        padding = ' ' * max_len
-        for cmdname, cmd in sorted(self.items()):
-            if not cmd.hidden:
-                print(' ', (cmdname + padding)[:max_len], cmd.short_description())
-        if self.rcfile:
-            print('''
-Use --rc-file=<configuration file> / -C <configuration file> before the command
-to specify a configuration file. Default to %s.
-''' % self.rcfile)
-        print('''%(pgm)s -h/--help
-      display this usage information and exit''' % self.__dict__)
-        if self.version:
-            print('''%(pgm)s -v/--version
-      display version configuration and exit''' % self.__dict__)
-        if self.copyright:
-            print('\n', self.copyright)
-
-    def usage_and_exit(self, status):
-        self.usage()
-        sys.exit(status)
-
-
-# base command classes #########################################################
-
-class Command(Configuration):
-    """Base class for command line commands.
-
-    Class attributes:
-
-    * `name`, the name of the command
-
-    * `min_args`, minimum number of arguments, None if unspecified
-
-    * `max_args`, maximum number of arguments, None if unspecified
-
-    * `arguments`, string describing arguments, used in command usage
-
-    * `hidden`, boolean flag telling if the command should be hidden, e.g. does
-      not appear in help's commands list
-
-    * `options`, options list, as allowed by :mod:configuration
-    """
-
-    arguments = ''
-    name = ''
-    # hidden from help ?
-    hidden = False
-    # max/min args, None meaning unspecified
-    min_args = None
-    max_args = None
-
-    @classmethod
-    def description(cls):
-        return cls.__doc__.replace('    ', '')
-
-    @classmethod
-    def short_description(cls):
-        return cls.description().split('.')[0]
-
-    def __init__(self, logger):
-        usage = '%%prog %s %s\n\n%s' % (self.name, self.arguments,
-                                        self.description())
-        Configuration.__init__(self, usage=usage)
-        self.logger = logger
-
-    def check_args(self, args):
-        """check command's arguments are provided"""
-        if self.min_args is not None and len(args) < self.min_args:
-            raise BadCommandUsage('missing argument')
-        if self.max_args is not None and len(args) > self.max_args:
-            raise BadCommandUsage('too many arguments')
-
-    def main_run(self, args, rcfile=None):
-        """Run the command and return status 0 if everything went fine.
-
-        If :exc:`CommandError` is raised by the underlying command, simply log
-        the error and return status 2.
-
-        Any other exceptions, including :exc:`BadCommandUsage` will be
-        propagated.
-        """
-        if rcfile:
-            self.load_file_configuration(rcfile)
-        args = self.load_command_line_configuration(args)
-        try:
-            self.check_args(args)
-            self.run(args)
-        except CommandError as err:
-            self.logger.error(err)
-            return 2
-        return 0
-
-    def run(self, args):
-        """run the command with its specific arguments"""
-        raise NotImplementedError()
-
-
-class ListCommandsCommand(Command):
-    """list available commands, useful for bash completion."""
-    name = 'listcommands'
-    arguments = '[command]'
-    hidden = True
-
-    def run(self, args):
-        """run the command with its specific arguments"""
-        if args:
-            command = args.pop()
-            cmd = _COMMANDS[command]
-            for optname, optdict in cmd.options:
-                print('--help')
-                print('--' + optname)
-        else:
-            commands = sorted(_COMMANDS.keys())
-            for command in commands:
-                cmd = _COMMANDS[command]
-                if not cmd.hidden:
-                    print(command)
-
-
-# deprecated stuff #############################################################
-
-_COMMANDS = CommandLine()
-
-DEFAULT_COPYRIGHT = '''\
-Copyright (c) 2004-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-http://www.logilab.fr/ -- mailto:contact@logilab.fr'''
-
-@deprecated('use cls.register(cli)')
-def register_commands(commands):
-    """register existing commands"""
-    for command_klass in commands:
-        _COMMANDS.register(command_klass)
-
-@deprecated('use args.pop(0)')
-def main_run(args, doc=None, copyright=None, version=None):
-    """command line tool: run command specified by argument list (without the
-    program name). Raise SystemExit with status 0 if everything went fine.
-
-    >>> main_run(sys.argv[1:])
-    """
-    _COMMANDS.doc = doc
-    _COMMANDS.copyright = copyright
-    _COMMANDS.version = version
-    _COMMANDS.run(args)
-
-@deprecated('use args.pop(0)')
-def pop_arg(args_list, expected_size_after=None, msg="Missing argument"):
-    """helper function to get and check command line arguments"""
-    try:
-        value = args_list.pop(0)
-    except IndexError:
-        raise BadCommandUsage(msg)
-    if expected_size_after is not None and len(args_list) > expected_size_after:
-        raise BadCommandUsage('too many arguments')
-    return value
-