libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -14,9 +14,9 @@
 """JSON reporter"""
 from __future__ import absolute_import, print_function
 
+import cgi
 import json
 import sys
-from cgi import escape
 
 from pylint.interfaces import IReporter
 from pylint.reporters import BaseReporter
@@ -35,7 +35,6 @@ class JSONReporter(BaseReporter):
 
     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,
@@ -44,14 +43,21 @@ class JSONReporter(BaseReporter):
             'column': message.column,
             'path': message.path,
             'symbol': message.symbol,
-            'message': escape(message.msg or ''),
+            # pylint: disable=deprecated-method; deprecated since 3.2.
+            'message': cgi.escape(message.msg or ''),
         })
 
-    def _display(self, layout):
+    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."""

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

@@ -19,16 +19,104 @@
 from __future__ import print_function
 
 import warnings
+import sys
 
-from logilab.common.ureports import TextWriter
-from logilab.common.textutils import colorize_ansi
+import six
 
 from pylint.interfaces import IReporter
 from pylint.reporters import BaseReporter
-import six
+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"""
@@ -106,6 +194,9 @@ class ColorizedTextReporter(TextReporter):
         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

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

@@ -0,0 +1,106 @@
+# copyright 2003-2015 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of pylint.
+#
+# pylint 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.
+#
+# pylint 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 pylint.  If not, see <http://www.gnu.org/licenses/>.
+"""Universal report objects and some formatting drivers.
+
+A way to create simple reports using python objects, primarily designed to be
+formatted as text and html.
+"""
+import os
+import sys
+
+import six
+
+
+class BaseWriter(object):
+    """base class for ureport writers"""
+
+    def format(self, layout, stream=None, encoding=None):
+        """format and write the given layout into the stream object
+
+        unicode policy: unicode strings may be found in the layout;
+        try to call stream.write with it, but give it back encoded using
+        the given encoding if it fails
+        """
+        if stream is None:
+            stream = sys.stdout
+        if not encoding:
+            encoding = getattr(stream, 'encoding', 'UTF-8')
+        self.encoding = encoding or 'UTF-8'
+        self.out = stream
+        self.begin_format()
+        layout.accept(self)
+        self.end_format()
+
+    def format_children(self, layout):
+        """recurse on the layout children and call their accept method
+        (see the Visitor pattern)
+        """
+        for child in getattr(layout, 'children', ()):
+            child.accept(self)
+
+    def writeln(self, string=u''):
+        """write a line in the output buffer"""
+        self.write(string + os.linesep)
+
+    def write(self, string):
+        """write a string in the output buffer"""
+        self.out.write(string)
+
+    def begin_format(self):
+        """begin to format a layout"""
+        self.section = 0
+
+    def end_format(self):
+        """finished to format a layout"""
+
+    def get_table_content(self, table):
+        """trick to get table content without actually writing it
+
+        return an aligned list of lists containing table cells values as string
+        """
+        result = [[]]
+        cols = table.cols
+        for cell in self.compute_content(table):
+            if cols == 0:
+                result.append([])
+                cols = table.cols
+            cols -= 1
+            result[-1].append(cell)
+        # fill missing cells
+        while len(result[-1]) < cols:
+            result[-1].append(u'')
+        return result
+
+    def compute_content(self, layout):
+        """trick to compute the formatting of children layout before actually
+        writing it
+
+        return an iterator on strings (one for each child element)
+        """
+        # Patch the underlying output stream with a fresh-generated stream,
+        # which is used to store a temporary representation of a child
+        # node.
+        out = self.out
+        try:
+            for child in layout.children:
+                stream = six.StringIO()
+                self.out = stream
+                child.accept(self)
+                yield stream.getvalue()
+        finally:
+            self.out = out

data/vendor/depot_tools/third_party/{logilab/common → pylint/reporters}/ureports/html_writer.py

@@ -1,28 +1,23 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2015 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
-# This file is part of logilab-common.
+# This file is part of pylint.
 #
-# logilab-common is free software: you can redistribute it and/or modify it under
+# pylint 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
+# pylint 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/>.
+# with pylint.  If not, see <http://www.gnu.org/licenses/>.
 """HTML formatting drivers for ureports"""
-__docformat__ = "restructuredtext en"
 
-from cgi import escape
-
-from six.moves import range
-
-from logilab.common.ureports import BaseWriter
+from pylint.reporters.ureports import BaseWriter
 
 
 class HTMLWriter(BaseWriter):
@@ -32,93 +27,58 @@ class HTMLWriter(BaseWriter):
         super(HTMLWriter, self).__init__()
         self.snippet = snippet
 
-    def handle_attrs(self, layout):
-        """get an attribute string from layout member attributes"""
-        attrs = u''
-        klass = getattr(layout, 'klass', None)
-        if klass:
-            attrs += u' class="%s"' % klass
-        nid = getattr(layout, 'id', None)
-        if nid:
-            attrs += u' id="%s"' % nid
-        return attrs
-
-    def begin_format(self, layout):
+    def begin_format(self):
         """begin to format a layout"""
-        super(HTMLWriter, self).begin_format(layout)
+        super(HTMLWriter, self).begin_format()
         if self.snippet is None:
             self.writeln(u'<html>')
             self.writeln(u'<body>')
 
-    def end_format(self, layout):
+    def end_format(self):
         """finished to format a layout"""
         if self.snippet is None:
             self.writeln(u'</body>')
             self.writeln(u'</html>')
 
-
     def visit_section(self, layout):
         """display a section as html, using div + h[section level]"""
         self.section += 1
-        self.writeln(u'<div%s>' % self.handle_attrs(layout))
+        self.writeln(u'<div>')
         self.format_children(layout)
         self.writeln(u'</div>')
         self.section -= 1
 
     def visit_title(self, layout):
         """display a title using <hX>"""
-        self.write(u'<h%s%s>' % (self.section, self.handle_attrs(layout)))
+        self.write(u'<h%s>' % self.section)
         self.format_children(layout)
         self.writeln(u'</h%s>' % self.section)
 
     def visit_table(self, layout):
         """display a table as html"""
-        self.writeln(u'<table%s>' % self.handle_attrs(layout))
+        self.writeln(u'<table>')
         table_content = self.get_table_content(layout)
-        for i in range(len(table_content)):
-            row = table_content[i]
+        for i, row in enumerate(table_content):
             if i == 0 and layout.rheaders:
                 self.writeln(u'<tr class="header">')
-            elif i+1 == len(table_content) and layout.rrheaders:
-                self.writeln(u'<tr class="header">')
             else:
-                self.writeln(u'<tr class="%s">' % (i%2 and 'even' or 'odd'))
-            for j in range(len(row)):
-                cell = row[j] or u'&#160;'
+                self.writeln(u'<tr class="%s">' % (u'even' if i % 2 else u'odd'))
+            for j, cell in enumerate(row):
+                cell = cell or u'&#160;'
                 if (layout.rheaders and i == 0) or \
-                   (layout.cheaders and j == 0) or \
-                   (layout.rrheaders and i+1 == len(table_content)) or \
-                   (layout.rcheaders and j+1 == len(row)):
+                   (layout.cheaders and j == 0):
                     self.writeln(u'<th>%s</th>' % cell)
                 else:
                     self.writeln(u'<td>%s</td>' % cell)
             self.writeln(u'</tr>')
         self.writeln(u'</table>')
 
-    def visit_list(self, layout):
-        """display a list as html"""
-        self.writeln(u'<ul%s>' % self.handle_attrs(layout))
-        for row in list(self.compute_content(layout)):
-            self.writeln(u'<li>%s</li>' % row)
-        self.writeln(u'</ul>')
-
     def visit_paragraph(self, layout):
         """display links (using <p>)"""
         self.write(u'<p>')
         self.format_children(layout)
         self.write(u'</p>')
 
-    def visit_span(self, layout):
-        """display links (using <p>)"""
-        self.write(u'<span%s>' % self.handle_attrs(layout))
-        self.format_children(layout)
-        self.write(u'</span>')
-
-    def visit_link(self, layout):
-        """display links (using <a>)"""
-        self.write(u' <a href="%s"%s>%s</a>' % (layout.url,
-                                                self.handle_attrs(layout),
-                                                layout.label))
     def visit_verbatimtext(self, layout):
         """display verbatim text (using <pre>)"""
         self.write(u'<pre>')

data/vendor/depot_tools/third_party/{logilab/common → pylint/reporters}/ureports/nodes.py

@@ -1,52 +1,79 @@
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2015 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
-# This file is part of logilab-common.
+# This file is part of pylint.
 #
-# logilab-common is free software: you can redistribute it and/or modify it under
+# pylint 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
+# pylint 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/>.
+# with pylint.  If not, see <http://www.gnu.org/licenses/>.
 """Micro reports objects.
 
 A micro report is a tree of layout and content objects.
 """
-__docformat__ = "restructuredtext en"
-
-from logilab.common.tree import VNode
 
 from six import string_types
 
-class BaseComponent(VNode):
-    """base report component
 
-    attributes
-    * id : the component's optional id
-    * klass : the component's optional klass
-    """
-    def __init__(self, id=None, klass=None):
-        VNode.__init__(self, id)
-        self.klass = klass
+class VNode(object):
+
+    def __init__(self, nid=None):
+        self.id = nid
+        # navigation
+        self.parent = None
+        self.children = []
 
-class BaseLayout(BaseComponent):
+    def __iter__(self):
+        return iter(self.children)
+
+    def append(self, child):
+        """add a node to children"""
+        self.children.append(child)
+        child.parent = self
+
+    def insert(self, index, child):
+        """insert a child node"""
+        self.children.insert(index, child)
+        child.parent = self
+
+    def _get_visit_name(self):
+        """
+        return the visit name for the mixed class. When calling 'accept', the
+        method <'visit_' + name returned by this method> will be called on the
+        visitor
+        """
+        try:
+            return self.TYPE.replace('-', '_')
+        except Exception:
+            return self.__class__.__name__.lower()
+
+    def accept(self, visitor, *args, **kwargs):
+        func = getattr(visitor, 'visit_%s' % self._get_visit_name())
+        return func(self, *args, **kwargs)
+
+    def leave(self, visitor, *args, **kwargs):
+        func = getattr(visitor, 'leave_%s' % self._get_visit_name())
+        return func(self, *args, **kwargs)
+
+
+class BaseLayout(VNode):
     """base container node
 
     attributes
-    * BaseComponent attributes
     * children : components in this table (i.e. the table's cells)
     """
     def __init__(self, children=(), **kwargs):
         super(BaseLayout, self).__init__(**kwargs)
         for child in children:
-            if isinstance(child, BaseComponent):
+            if isinstance(child, VNode):
                 self.append(child)
             else:
                 self.add_text(child)
@@ -70,11 +97,10 @@ class BaseLayout(BaseComponent):
 
 # non container nodes #########################################################
 
-class Text(BaseComponent):
+class Text(VNode):
     """a text portion
 
     attributes :
-    * BaseComponent attributes
     * data : the text value as an encoded or unicode string
     """
     def __init__(self, data, escaped=True, **kwargs):
@@ -85,47 +111,14 @@ class Text(BaseComponent):
         self.escaped = escaped
         self.data = data
 
+
 class VerbatimText(Text):
     """a verbatim text, display the raw data
 
     attributes :
-    * BaseComponent attributes
     * data : the text value as an encoded or unicode string
     """
 
-class Link(BaseComponent):
-    """a labelled link
-
-    attributes :
-    * BaseComponent attributes
-    * url : the link's target (REQUIRED)
-    * label : the link's label as a string (use the url by default)
-    """
-    def __init__(self, url, label=None, **kwargs):
-        super(Link, self).__init__(**kwargs)
-        assert url
-        self.url = url
-        self.label = label or url
-
-
-class Image(BaseComponent):
-    """an embedded or a single image
-
-    attributes :
-    * BaseComponent attributes
-    * filename : the image's filename (REQUIRED)
-    * stream : the stream object containing the image data (REQUIRED)
-    * title : the image's optional title
-    """
-    def __init__(self, filename, stream, title=None, **kwargs):
-        super(Image, self).__init__(**kwargs)
-        assert filename
-        assert stream
-        self.filename = filename
-        self.stream = stream
-        self.title = title
-
-
 # container nodes #############################################################
 
 class Section(BaseLayout):
@@ -146,6 +139,7 @@ class Section(BaseLayout):
         if title:
             self.insert(0, Title(children=(title,)))
 
+
 class Title(BaseLayout):
     """a title
 
@@ -155,14 +149,6 @@ class Title(BaseLayout):
     A title must not contains a section nor a paragraph!
     """
 
-class Span(BaseLayout):
-    """a title
-
-    attributes :
-    * BaseLayout attributes
-
-    A span should only contains Text and Link nodes (in-line elements)
-    """
 
 class Paragraph(BaseLayout):
     """a simple text paragraph
@@ -173,6 +159,7 @@ class Paragraph(BaseLayout):
     A paragraph must not contains a section !
     """
 
+
 class Table(BaseLayout):
     """some tabular data
 
@@ -184,7 +171,7 @@ class Table(BaseLayout):
     * title : the table's optional title
     """
     def __init__(self, cols, title=None,
-                 rheaders=0, cheaders=0, rrheaders=0, rcheaders=0,
+                 rheaders=0, cheaders=0,
                  **kwargs):
         super(Table, self).__init__(**kwargs)
         assert isinstance(cols, int)
@@ -192,12 +179,3 @@ class Table(BaseLayout):
         self.title = title
         self.rheaders = rheaders
         self.cheaders = cheaders
-        self.rrheaders = rrheaders
-        self.rcheaders = rcheaders
-
-class List(BaseLayout):
-    """some list data
-
-    attributes :
-    * BaseLayout attributes
-    """