libv8 7.3.492.27.1 → 8.4.255.0

data/vendor/depot_tools/third_party/pylint/reporters/__init__.py

@@ -1,149 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# 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.
-"""utilities methods and classes for reporters"""
-from __future__ import print_function
-
-import sys
-import locale
-import os
-import warnings
-
-import six
-
-CMPS = ['=', '-', '+']
-
-# py3k has no more cmp builtin
-if sys.version_info >= (3, 0):
-    def cmp(a, b): # pylint: disable=redefined-builtin
-        return (a > b) - (a < b)
-
-def diff_string(old, new):
-    """given a old and new int value, return a string representing the
-    difference
-    """
-    diff = abs(old - new)
-    diff_str = "%s%s" % (CMPS[cmp(old, new)], diff and ('%.2f' % diff) or '')
-    return diff_str
-
-
-class BaseReporter(object):
-    """base class for reporters
-
-    symbols: show short symbolic names for messages.
-    """
-
-    extension = ''
-
-    def __init__(self, output=None):
-        self.linter = None
-        self.section = 0
-        self.out = None
-        self.out_encoding = None
-        self.set_output(output)
-        # Build the path prefix to strip to get relative paths
-        self.path_strip_prefix = os.getcwd() + os.sep
-
-    def handle_message(self, msg):
-        """Handle a new message triggered on the current file.
-
-        Invokes the legacy add_message API by default."""
-        self.add_message(
-            msg.msg_id, (msg.abspath, msg.module, msg.obj, msg.line, msg.column),
-            msg.msg)
-
-    def add_message(self, msg_id, location, msg):
-        """Deprecated, do not use."""
-        # pylint: disable=no-self-use,unused-argument
-        msg = ("This method is deprecated, use handle_message instead. "
-               "It will be removed in Pylint 1.6.")
-        warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
-    def set_output(self, output=None):
-        """set output stream"""
-        self.out = output or sys.stdout
-
-    if six.PY3:
-        encode = lambda self, string: string
-    else:
-        def encode(self, string):
-            if not isinstance(string, six.text_type):
-                return string
-            encoding = (getattr(self.out, 'encoding', None) or
-                        locale.getdefaultlocale()[1] or
-                        sys.getdefaultencoding())
-            # errors=replace, we don't want to crash when attempting to show
-            # source code line that can't be encoded with the current locale
-            # settings
-            return string.encode(encoding, 'replace')
-
-    def writeln(self, string=''):
-        """write a line in the output buffer"""
-        print(self.encode(string), file=self.out)
-
-    def display_reports(self, layout):
-        """display results encapsulated in the layout tree"""
-        self.section = 0
-        if hasattr(layout, 'report_id'):
-            layout.children[0].children[0].data += ' (%s)' % layout.report_id
-        self._display(layout)
-
-    def display_results(self, layout):
-        warnings.warn("display_results is deprecated, use display_reports instead. "
-                      "The former will be removed in Pylint 2.0.",
-                      DeprecationWarning)
-        self.display_reports(layout)
-
-    def _display(self, layout):
-        """display the layout"""
-        raise NotImplementedError()
-
-    def display_messages(self, layout):
-        """Hook for displaying the messages of the reporter
-
-        This will be called whenever the underlying messages
-        needs to be displayed. For some reporters, it probably
-        doesn't make sense to display messages as soon as they
-        are available, so some mechanism of storing them could be used.
-        This method can be implemented to display them after they've
-        been aggregated.
-        """
-
-    # Event callbacks
-
-    def on_set_current_module(self, module, filepath):
-        """Hook called when a module starts to be analysed."""
-
-    def on_close(self, stats, previous_stats):
-        """Hook called when a module finished analyzing."""
-
-
-class CollectingReporter(BaseReporter):
-    """collects messages"""
-
-    name = 'collector'
-
-    def __init__(self):
-        BaseReporter.__init__(self)
-        self.messages = []
-
-    def handle_message(self, msg):
-        self.messages.append(msg)
-
-    _display = None
-
-
-def initialize(linter):
-    """initialize linter with reporters in this package """
-    from pylint import utils
-    utils.register_plugins(linter, __path__[0])

data/vendor/depot_tools/third_party/pylint/reporters/guireporter.py

@@ -1,27 +0,0 @@
-""" reporter used by gui.py """
-
-import sys
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter
-from pylint.reporters.ureports.text_writer import TextWriter
-
-
-class GUIReporter(BaseReporter):
-    """saves messages"""
-
-    __implements__ = IReporter
-    extension = ''
-
-    def __init__(self, gui, output=sys.stdout):
-        """init"""
-        BaseReporter.__init__(self, output)
-        self.gui = gui
-
-    def handle_message(self, msg):
-        """manage message of different type and in the context of path"""
-        self.gui.msg_queue.put(msg)
-
-    def _display(self, layout):
-        """launch layouts display"""
-        TextWriter().format(layout, self.out)

data/vendor/depot_tools/third_party/pylint/reporters/html.py

@@ -1,108 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# 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.
-"""HTML reporter"""
-
-import itertools
-import string
-import sys
-
-import six
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter
-from pylint.reporters.ureports.html_writer import HTMLWriter
-from pylint.reporters.ureports.nodes import Section, Table
-
-
-class HTMLReporter(BaseReporter):
-    """report messages and layouts in HTML"""
-
-    __implements__ = IReporter
-    name = 'html'
-    extension = 'html'
-
-    def __init__(self, output=sys.stdout):
-        BaseReporter.__init__(self, output)
-        self.msgs = []
-        # Add placeholders for title and parsed messages
-        self.header = None
-        self.msgargs = []
-
-    @staticmethod
-    def _parse_msg_template(msg_template):
-        formatter = string.Formatter()
-        parsed = formatter.parse(msg_template)
-        for item in parsed:
-            if item[1]:
-                yield item[1]
-
-    def _parse_template(self):
-        """Helper function to parse the message template"""
-        self.header = []
-        if self.linter.config.msg_template:
-            msg_template = self.linter.config.msg_template
-        else:
-            msg_template = '{category}{module}{obj}{line}{column}{msg}'
-
-        _header, _msgs = itertools.tee(self._parse_msg_template(msg_template))
-        self.header = list(_header)
-        self.msgargs = list(_msgs)
-
-    def handle_message(self, msg):
-        """manage message of different type and in the context of path"""
-
-        # It would be better to do this in init, but currently we do not
-        # have access to the linter (as it is setup in lint.set_reporter()
-        # Therefore we try to parse just the once.
-        if self.header is None:
-            self._parse_template()
-
-        # We want to add the lines given by the template
-        values = [getattr(msg, field) for field in self.msgargs]
-        self.msgs += [value if isinstance(value, six.text_type) else str(value)
-                      for value in values]
-
-    def set_output(self, output=None):
-        """set output stream
-
-        messages buffered for old output is processed first"""
-        if self.out and self.msgs:
-            self._display(Section())
-        BaseReporter.set_output(self, output)
-
-    def _display(self, layout):
-        """launch layouts display
-
-        overridden from BaseReporter to add insert the messages section
-        (in add_message, message is not displayed, just collected so it
-        can be displayed in an html table)
-        """
-        HTMLWriter().format(layout, self.out)
-
-    def display_messages(self, layout):
-        if self.msgs:
-            # add stored messages to the layout
-            msgs = self.header
-            cols = len(self.header)
-            msgs += self.msgs
-            sect = Section('Messages')
-            layout.append(sect)
-            sect.append(Table(cols=cols, children=msgs, rheaders=1))
-            self.msgs = []
-            self._display(layout)
-
-
-def register(linter):
-    """Register the reporter classes with the linter."""
-    linter.register_reporter(HTMLReporter)

data/vendor/depot_tools/third_party/pylint/reporters/json.py

@@ -1,64 +0,0 @@
-# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
-# 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.
-"""JSON reporter"""
-from __future__ import absolute_import, print_function
-
-import cgi
-import json
-import sys
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter
-
-
-class JSONReporter(BaseReporter):
-    """Report messages and layouts in JSON."""
-
-    __implements__ = IReporter
-    name = 'json'
-    extension = 'json'
-
-    def __init__(self, output=sys.stdout):
-        BaseReporter.__init__(self, output)
-        self.messages = []
-
-    def handle_message(self, message):
-        """Manage message of different type and in the context of path."""
-        self.messages.append({
-            'type': message.category,
-            'module': message.module,
-            'obj': message.obj,
-            'line': message.line,
-            'column': message.column,
-            'path': message.path,
-            'symbol': message.symbol,
-            # pylint: disable=deprecated-method; deprecated since 3.2.
-            'message': cgi.escape(message.msg or ''),
-        })
-
-    def display_messages(self, layout):
-        """Launch layouts display"""
-        if self.messages:
-            print(json.dumps(self.messages, indent=4), file=self.out)
-
-    def display_reports(self, _):
-        """Don't do nothing in this reporter."""
-
-    def _display(self, layout):
-        """Don't do nothing."""
-
-
-def register(linter):
-    """Register the reporter classes with the linter."""
-    linter.register_reporter(JSONReporter)

data/vendor/depot_tools/third_party/pylint/reporters/text.py

@@ -1,237 +0,0 @@
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# 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.
-"""Plain text reporters:
-
-:text: the default one grouping messages by module
-:colorized: an ANSI colorized text reporter
-"""
-from __future__ import print_function
-
-import warnings
-import sys
-
-import six
-
-from pylint.interfaces import IReporter
-from pylint.reporters import BaseReporter
-from pylint import utils
-from pylint.reporters.ureports.text_writer import TextWriter
-
-
-TITLE_UNDERLINES = ['', '=', '-', '.']
-
-ANSI_PREFIX = '\033['
-ANSI_END = 'm'
-ANSI_RESET = '\033[0m'
-ANSI_STYLES = {
-    'reset': "0",
-    'bold': "1",
-    'italic': "3",
-    'underline': "4",
-    'blink': "5",
-    'inverse': "7",
-    'strike': "9",
-}
-ANSI_COLORS = {
-    'reset': "0",
-    'black': "30",
-    'red': "31",
-    'green': "32",
-    'yellow': "33",
-    'blue': "34",
-    'magenta': "35",
-    'cyan': "36",
-    'white': "37",
-}
-
-def _get_ansi_code(color=None, style=None):
-    """return ansi escape code corresponding to color and style
-
-    :type color: str or None
-    :param color:
-      the color name (see `ANSI_COLORS` for available values)
-      or the color number when 256 colors are available
-
-    :type style: str or None
-    :param style:
-      style string (see `ANSI_COLORS` for available values). To get
-      several style effects at the same time, use a coma as separator.
-
-    :raise KeyError: if an unexistent color or style identifier is given
-
-    :rtype: str
-    :return: the built escape code
-    """
-    ansi_code = []
-    if style:
-        style_attrs = utils._splitstrip(style)
-        for effect in style_attrs:
-            ansi_code.append(ANSI_STYLES[effect])
-    if color:
-        if color.isdigit():
-            ansi_code.extend(['38', '5'])
-            ansi_code.append(color)
-        else:
-            ansi_code.append(ANSI_COLORS[color])
-    if ansi_code:
-        return ANSI_PREFIX + ';'.join(ansi_code) + ANSI_END
-    return ''
-
-def colorize_ansi(msg, color=None, style=None):
-    """colorize message by wrapping it with ansi escape codes
-
-    :type msg: str or unicode
-    :param msg: the message string to colorize
-
-    :type color: str or None
-    :param color:
-      the color identifier (see `ANSI_COLORS` for available values)
-
-    :type style: str or None
-    :param style:
-      style string (see `ANSI_COLORS` for available values). To get
-      several style effects at the same time, use a coma as separator.
-
-    :raise KeyError: if an unexistent color or style identifier is given
-
-    :rtype: str or unicode
-    :return: the ansi escaped string
-    """
-    # If both color and style are not defined, then leave the text as is
-    if color is None and style is None:
-        return msg
-    escape_code = _get_ansi_code(color, style)
-    # If invalid (or unknown) color, don't wrap msg with ansi codes
-    if escape_code:
-        return '%s%s%s' % (escape_code, msg, ANSI_RESET)
-    return msg
-
-
-class TextReporter(BaseReporter):
-    """reports messages and layouts in plain text"""
-
-    __implements__ = IReporter
-    name = 'text'
-    extension = 'txt'
-    line_format = '{C}:{line:3d},{column:2d}: {msg} ({symbol})'
-
-    def __init__(self, output=None):
-        BaseReporter.__init__(self, output)
-        self._modules = set()
-        self._template = None
-
-    def on_set_current_module(self, module, filepath):
-        self._template = six.text_type(self.linter.config.msg_template or self.line_format)
-
-    def write_message(self, msg):
-        """Convenience method to write a formated message with class default template"""
-        self.writeln(msg.format(self._template))
-
-    def handle_message(self, msg):
-        """manage message of different type and in the context of path"""
-        if msg.module not in self._modules:
-            if msg.module:
-                self.writeln('************* Module %s' % msg.module)
-                self._modules.add(msg.module)
-            else:
-                self.writeln('************* ')
-        self.write_message(msg)
-
-    def _display(self, layout):
-        """launch layouts display"""
-        print(file=self.out)
-        TextWriter().format(layout, self.out)
-
-
-class ParseableTextReporter(TextReporter):
-    """a reporter very similar to TextReporter, but display messages in a form
-    recognized by most text editors :
-
-    <filename>:<linenum>:<msg>
-    """
-    name = 'parseable'
-    line_format = '{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}'
-
-    def __init__(self, output=None):
-        warnings.warn('%s output format is deprecated. This is equivalent '
-                      'to --msg-template=%s' % (self.name, self.line_format),
-                      DeprecationWarning)
-        TextReporter.__init__(self, output)
-
-
-class VSTextReporter(ParseableTextReporter):
-    """Visual studio text reporter"""
-    name = 'msvs'
-    line_format = '{path}({line}): [{msg_id}({symbol}){obj}] {msg}'
-
-
-class ColorizedTextReporter(TextReporter):
-    """Simple TextReporter that colorizes text output"""
-
-    name = 'colorized'
-    COLOR_MAPPING = {
-        "I" : ("green", None),
-        'C' : (None, "bold"),
-        'R' : ("magenta", "bold, italic"),
-        'W' : ("blue", None),
-        'E' : ("red", "bold"),
-        'F' : ("red", "bold, underline"),
-        'S' : ("yellow", "inverse"), # S stands for module Separator
-    }
-
-    def __init__(self, output=None, color_mapping=None):
-        TextReporter.__init__(self, output)
-        self.color_mapping = color_mapping or \
-                             dict(ColorizedTextReporter.COLOR_MAPPING)
-        if sys.platform == 'win32':
-            import colorama
-            self.out = colorama.AnsiToWin32(self.out)
-
-    def _get_decoration(self, msg_id):
-        """Returns the tuple color, style associated with msg_id as defined
-        in self.color_mapping
-        """
-        try:
-            return self.color_mapping[msg_id[0]]
-        except KeyError:
-            return None, None
-
-    def handle_message(self, msg):
-        """manage message of different types, and colorize output
-        using ansi escape codes
-        """
-        if msg.module not in self._modules:
-            color, style = self._get_decoration('S')
-            if msg.module:
-                modsep = colorize_ansi('************* Module %s' % msg.module,
-                                       color, style)
-            else:
-                modsep = colorize_ansi('************* %s' % msg.module,
-                                       color, style)
-            self.writeln(modsep)
-            self._modules.add(msg.module)
-        color, style = self._get_decoration(msg.C)
-
-        msg = msg._replace(
-            **{attr: colorize_ansi(getattr(msg, attr), color, style)
-               for attr in ('msg', 'symbol', 'category', 'C')})
-        self.write_message(msg)
-
-
-def register(linter):
-    """Register the reporter classes with the linter."""
-    linter.register_reporter(TextReporter)
-    linter.register_reporter(ParseableTextReporter)
-    linter.register_reporter(VSTextReporter)
-    linter.register_reporter(ColorizedTextReporter)