libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/pylint/epylint.py

@@ -48,10 +48,14 @@ its output.
 """
 from __future__ import print_function
 
-import sys, os
+import os
 import os.path as osp
+import sys
 from subprocess import Popen, PIPE
 
+import six
+
+
 def _get_env():
     '''Extracts the environment PYTHONPATH and appends the current sys.path to
     those.'''
@@ -154,12 +158,12 @@ def py_run(command_options='', return_std=False, stdout=None, stderr=None,
         else:
             stderr = sys.stderr
     # Call pylint in a subprocess
-    p = Popen(command_line, shell=True, stdout=stdout, stderr=stderr,
-              env=_get_env(), universal_newlines=True)
-    p.wait()
+    process = Popen(command_line, shell=True, stdout=stdout, stderr=stderr,
+                    env=_get_env(), universal_newlines=True)
+    proc_stdout, proc_stderr = process.communicate()
     # Return standard output and error
     if return_std:
-        return (p.stdout, p.stderr)
+        return six.moves.StringIO(proc_stdout), six.moves.StringIO(proc_stderr)
 
 
 def Run():

data/vendor/depot_tools/third_party/pylint/extensions/check_docs.py

@@ -0,0 +1,311 @@
+"""Pylint plugin for parameter documentation checking in Sphinx, Google or
+Numpy style docstrings
+"""
+from __future__ import print_function, division, absolute_import
+
+import re
+
+from pylint.interfaces import IAstroidChecker
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import node_frame_class
+
+
+def space_indentation(s):
+    """The number of leading spaces in a string
+
+    :param str s: input string
+
+    :rtype: int
+    :return: number of leading spaces
+    """
+    return len(s) - len(s.lstrip(' '))
+
+
+class ParamDocChecker(BaseChecker):
+    """Checker for parameter documentation in Sphinx, Google or Numpy style
+    docstrings
+
+    * Check that all function, method and constructor parameters are mentioned
+      in the params and types part of the docstring. By convention,
+      constructor parameters are documented in the class docstring.
+    * Check that there are no naming inconsistencies between the signature and
+      the documentation, i.e. also report documented parameters that are missing
+      in the signature. This is important to find cases where parameters are
+      renamed only in the code, not in the documentation.
+
+    Activate this checker by adding the line::
+
+        load-plugins=pylint.extensions.check_docs
+
+    to the ``MASTER`` section of your ``.pylintrc``.
+
+    :param linter: linter object
+    :type linter: :class:`pylint.lint.PyLinter`
+    """
+    __implements__ = IAstroidChecker
+
+    name = 'param_checks'
+    msgs = {
+        'W9003': ('"%s" missing or differing in parameter documentation',
+                  'missing-param-doc',
+                  'Please add parameter declarations for all parameters.'),
+        'W9004': ('"%s" missing or differing in parameter type documentation',
+                  'missing-type-doc',
+                  'Please add parameter type declarations for all parameters.'),
+    }
+
+    options = (('accept-no-param-doc',
+                {'default': True, 'type' : 'yn', 'metavar' : '<y or n>',
+                 'help': 'Whether to accept totally missing parameter '
+                         'documentation in a docstring of a function that has '
+                         'parameters'
+                }),
+              )
+
+    priority = -2
+
+    def __init__(self, linter=None):
+        BaseChecker.__init__(self, linter)
+
+    constructor_names = set(["__init__", "__new__"])
+
+    def visit_functiondef(self, node):
+        """Called for function and method definitions (def).
+
+        :param node: Node for a function or method definition in the AST
+        :type node: :class:`astroid.scoped_nodes.Function`
+        """
+        if node.name in self.constructor_names:
+            class_node = node_frame_class(node)
+            if class_node is not None:
+                self.check_arguments_in_docstring(
+                    class_node.doc, node.args, class_node)
+                return
+        self.check_arguments_in_docstring(node.doc, node.args, node)
+
+    re_for_parameters_see = re.compile(r"""
+        For\s+the\s+(other)?\s*parameters\s*,\s+see
+        """, re.X | re.S)
+
+    re_sphinx_param_in_docstring = re.compile(r"""
+        :param                  # Sphinx keyword
+        \s+                     # whitespace
+
+        (?:                     # optional type declaration
+        (\w+)
+        \s+
+        )?
+
+        (\w+)                   # Parameter name
+        \s*                     # whitespace
+        :                       # final colon
+        """, re.X | re.S)
+
+    re_sphinx_type_in_docstring = re.compile(r"""
+        :type                   # Sphinx keyword
+        \s+                     # whitespace
+        (\w+)                   # Parameter name
+        \s*                     # whitespace
+        :                       # final colon
+        """, re.X | re.S)
+
+    re_google_param_section = re.compile(r"""
+        ^([ ]*)   Args \s*:   \s*?$   # Google parameter header
+        (  .* )                       # section
+        """, re.X | re.S | re.M)
+
+    re_google_param_line = re.compile(r"""
+        \s*  (\w+)                    # identifier
+        \s*  ( [(] .*? [)] )? \s* :   # optional type declaration
+        \s*  ( \w+ )?                 # beginning of optional description
+    """, re.X)
+
+    re_numpy_param_section = re.compile(r"""
+        ^([ ]*)   Parameters   \s*?$   # Numpy parameters header
+        \s*     [-=]+   \s*?$          # underline
+        (  .* )                        # section
+    """, re.X | re.S | re.M)
+
+    re_numpy_param_line = re.compile(r"""
+        \s*  (\w+)                    # identifier
+        \s*  :                        
+        \s*  ( \w+ )?                 # optional type declaration
+    """, re.X)
+
+    not_needed_param_in_docstring = set(['self', 'cls'])
+
+    def check_arguments_in_docstring(self, doc, arguments_node, warning_node):
+        """Check that all parameters in a function, method or class constructor
+        on the one hand and the parameters mentioned in the parameter
+        documentation (e.g. the Sphinx tags 'param' and 'type') on the other
+        hand are consistent with each other.
+
+        * Undocumented parameters except 'self' are noticed.
+        * Undocumented parameter types except for 'self' and the ``*<args>``
+          and ``**<kwargs>`` parameters are noticed.
+        * Parameters mentioned in the parameter documentation that don't or no
+          longer exist in the function parameter list are noticed.
+        * If the text "For the parameters, see" or "For the other parameters,
+          see" (ignoring additional whitespace) is mentioned in the docstring,
+          missing parameter documentation is tolerated.
+        * If there's no Sphinx style, Google style or NumPy style parameter
+          documentation at all, i.e. ``:param`` is never mentioned etc., the
+          checker assumes that the parameters are documented in another format
+          and the absence is tolerated.
+
+        :param doc: Docstring for the function, method or class.
+        :type doc: str
+
+        :param arguments_node: Arguments node for the function, method or
+            class constructor.
+        :type arguments_node: :class:`astroid.scoped_nodes.Arguments`
+
+        :param warning_node: The node to assign the warnings to
+        :type warning_node: :class:`astroid.scoped_nodes.Node`
+        """
+        # Tolerate missing param or type declarations if there is a link to
+        # another method carrying the same name.
+        if doc is None:
+            return
+
+        doc = doc.expandtabs()
+
+        tolerate_missing_params = self.re_for_parameters_see.search(doc) is not None
+
+        # Collect the function arguments.
+        expected_argument_names = [arg.name for arg in arguments_node.args]
+        expected_argument_names += [arg.name for arg in arguments_node.kwonlyargs]
+        not_needed_type_in_docstring = (
+            self.not_needed_param_in_docstring.copy())
+
+        if arguments_node.vararg is not None:
+            expected_argument_names.append(arguments_node.vararg)
+            not_needed_type_in_docstring.add(arguments_node.vararg)
+        if arguments_node.kwarg is not None:
+            expected_argument_names.append(arguments_node.kwarg)
+            not_needed_type_in_docstring.add(arguments_node.kwarg)
+        params_with_doc, params_with_type = self.match_param_docs(doc)
+
+        # Tolerate no parameter documentation at all.
+        if (not params_with_doc and not params_with_type
+                and self.config.accept_no_param_doc):
+            tolerate_missing_params = True
+
+        def _compare_args(found_argument_names, message_id, not_needed_names):
+            """Compare the found argument names with the expected ones and
+            generate a message if there are inconsistencies.
+
+            :param list found_argument_names: argument names found in the
+                docstring
+
+            :param str message_id: pylint message id
+
+            :param not_needed_names: names that may be omitted
+            :type not_needed_names: set of str
+            """
+            if not tolerate_missing_params:
+                missing_or_differing_argument_names = (
+                    (set(expected_argument_names) ^ set(found_argument_names))
+                    - not_needed_names)
+            else:
+                missing_or_differing_argument_names = (
+                    (set(found_argument_names) - set(expected_argument_names))
+                    - not_needed_names)
+
+            if missing_or_differing_argument_names:
+                self.add_message(
+                    message_id,
+                    args=(', '.join(
+                        sorted(missing_or_differing_argument_names)),),
+                    node=warning_node)
+
+        _compare_args(params_with_doc, 'missing-param-doc',
+                      self.not_needed_param_in_docstring)
+        _compare_args(params_with_type, 'missing-type-doc',
+                      not_needed_type_in_docstring)
+
+    def match_param_docs(self, doc):
+        """Match parameter documentation in docstrings written in Sphinx, Google
+        or NumPy style
+
+        :param str doc: docstring
+
+        :return: tuple of lists of str: params_with_doc, params_with_type
+        """
+        params_with_doc = []
+        params_with_type = []
+
+        if self.re_sphinx_param_in_docstring.search(doc) is not None:
+            # Sphinx param declarations
+            for match in re.finditer(self.re_sphinx_param_in_docstring, doc):
+                name = match.group(2)
+                params_with_doc.append(name)
+                if match.group(1) is not None:
+                    params_with_type.append(name)
+
+            # Sphinx type declarations
+            params_with_type += re.findall(
+                self.re_sphinx_type_in_docstring, doc)
+        else:
+            match = self.re_google_param_section.search(doc)
+            if match is not None:
+                is_google = True
+                re_line = self.re_google_param_line
+            else:
+                match = self.re_numpy_param_section.search(doc)
+                if match is not None:
+                    is_google = False
+                    re_line = self.re_numpy_param_line
+                else:
+                    # some other documentation style
+                    return [], []
+
+            min_indentation = len(match.group(1))
+            if is_google:
+                min_indentation += 1
+
+            prev_param_name = None
+            is_first = True
+            for line in match.group(2).splitlines():
+                if not line.strip():
+                    continue
+                indentation = space_indentation(line)
+                if indentation < min_indentation:
+                    break
+
+                # The first line after the header defines the minimum
+                # indentation.
+                if is_first:
+                    min_indentation = indentation
+                    is_first = False
+
+                if indentation > min_indentation:
+                    # Lines with more than minimum indentation must contain a
+                    # description.
+                    if (not params_with_doc
+                            or params_with_doc[-1] != prev_param_name):
+                        assert prev_param_name is not None
+                        params_with_doc.append(prev_param_name)
+                else:
+                    # Lines with minimum indentation must contain the beginning
+                    # of a new parameter documentation.
+                    match = re_line.match(line)
+                    if match is None:
+                        break
+                    prev_param_name = match.group(1)
+                    if match.group(2) is not None:
+                        params_with_type.append(prev_param_name)
+
+                    if is_google and match.group(3) is not None:
+                        params_with_doc.append(prev_param_name)
+
+        return params_with_doc, params_with_type
+
+
+def register(linter):
+    """Required method to auto register this checker.
+
+    :param linter: Main interface object for Pylint plugins
+    :type linter: Pylint object
+    """
+    linter.register_checker(ParamDocChecker(linter))

data/vendor/depot_tools/third_party/pylint/extensions/check_elif.py

@@ -0,0 +1,62 @@
+import astroid
+from pylint.checkers import BaseTokenChecker
+from pylint.checkers.utils import check_messages
+from pylint.interfaces import ITokenChecker, IAstroidChecker
+
+
+class ElseifUsedChecker(BaseTokenChecker):
+    """Checks for use of "else if" when a "elif" could be used
+    """
+
+    __implements__ = (ITokenChecker, IAstroidChecker)
+    name = 'elseifused'
+    msgs = {'R5501': ('Consider using "elif" instead of "else if"',
+                      'else-if-used',
+                      'Used when an else statement is immediately followed by '
+                      'an if statement and does not contain statements that '
+                      'would be unrelated to it.'),
+           }
+
+    def __init__(self, linter=None):
+        BaseTokenChecker.__init__(self, linter)
+        self._init()
+
+    def _init(self):
+        self._elifs = []
+        self._if_counter = 0
+
+    def process_tokens(self, tokens):
+        # Process tokens and look for 'if' or 'elif'
+        for _, token, _, _, _ in tokens:
+            if token == 'elif':
+                self._elifs.append(True)
+            elif token == 'if':
+                self._elifs.append(False)
+
+    def leave_module(self, _):
+        self._init()
+
+    def visit_ifexp(self, _):
+        self._if_counter += 1
+
+    def visit_comprehension(self, node):
+        self._if_counter += len(node.ifs)
+
+    @check_messages('else-if-used')
+    def visit_if(self, node):
+        if isinstance(node.parent, astroid.If):
+            orelse = node.parent.orelse
+            # current if node must directly follow a "else"
+            if orelse and orelse == [node]:
+                if not self._elifs[self._if_counter]:
+                    self.add_message('else-if-used', node=node)
+        self._if_counter += 1
+
+
+def register(linter):
+    """Required method to auto register this checker.
+
+    :param linter: Main interface object for Pylint plugins
+    :type linter: Pylint object
+    """
+    linter.register_checker(ElseifUsedChecker(linter))

data/vendor/depot_tools/third_party/{logilab/common → pylint}/graph.py

@@ -1,41 +1,29 @@
-# 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.
+# 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.
 #
-# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# 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 Lesser General Public License for more
-# details.
+# FOR A PARTICULAR PURPOSE. See the GNU 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/>.
+# 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.
+
+# This file was copied from logilab-common with the same license:
+# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 """Graph manipulation utilities.
 
 (dot generation adapted from pypy/translator/tool/make_dot.py)
 """
 
-__docformat__ = "restructuredtext en"
-
-__metaclass__ = type
-
 import os.path as osp
 import os
 import sys
 import tempfile
 import codecs
-import errno
-
-def escape(value):
-    """Make <value> usable in a dot file."""
-    lines = [line.replace('"', '\\"') for line in value.split('\n')]
-    data = '\\l'.join(lines)
-    return '\\n' + data
 
 def target_info_from_filename(filename):
     """Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
@@ -45,10 +33,12 @@ def target_info_from_filename(filename):
     return storedir, basename, target
 
 
-class DotBackend:
+class DotBackend(object):
     """Dot File backend."""
     def __init__(self, graphname, rankdir=None, size=None, ratio=None,
-            charset='utf-8', renderer='dot', additionnal_param={}):
+                 charset='utf-8', renderer='dot', additional_param=None):
+        if additional_param is None:
+            additional_param = {}
         self.graphname = graphname
         self.renderer = renderer
         self.lines = []
@@ -64,7 +54,7 @@ class DotBackend:
             assert charset.lower() in ('utf-8', 'iso-8859-1', 'latin1'), \
                    'unsupported charset %s' % charset
             self.emit('charset="%s"' % charset)
-        for param in sorted(additionnal_param.items()):
+        for param in additional_param.items():
             self.emit('='.join(param))
 
     def get_source(self):
@@ -95,7 +85,7 @@ class DotBackend:
             else:
                 dotfile = '%s.dot' % name
         if outputfile is not None:
-            storedir, basename, target = target_info_from_filename(outputfile)
+            storedir, _, target = target_info_from_filename(outputfile)
             if target != "dot":
                 pdot, dot_sourcepath = tempfile.mkstemp(".dot", name)
                 os.close(pdot)
@@ -111,22 +101,16 @@ class DotBackend:
         pdot.write(self.source)
         pdot.close()
         if target != 'dot':
-            if sys.platform == 'win32':
-                use_shell = True
+            use_shell = sys.platform == 'win32'
+            if mapfile:
+                subprocess.call([self.renderer, '-Tcmapx', '-o',
+                                 mapfile, '-T', target, dot_sourcepath,
+                                 '-o', outputfile],
+                                shell=use_shell)
             else:
-                use_shell = False
-            try:
-                if mapfile:
-                    subprocess.call([self.renderer,  '-Tcmapx', '-o', mapfile, '-T', target, dot_sourcepath, '-o', outputfile],
-                                    shell=use_shell)
-                else:
-                    subprocess.call([self.renderer, '-T',  target,
-                                     dot_sourcepath, '-o',  outputfile],
-                                    shell=use_shell)
-            except OSError as e:
-                if e.errno == errno.ENOENT:
-                    e.strerror = 'File not found: {0}'.format(self.renderer)
-                    raise
+                subprocess.call([self.renderer, '-T', target,
+                                 dot_sourcepath, '-o', outputfile],
+                                shell=use_shell)
             os.unlink(dot_sourcepath)
         return outputfile
 
@@ -140,7 +124,7 @@ class DotBackend:
         """
         attrs = ['%s="%s"' % (prop, value) for prop, value in props.items()]
         n_from, n_to = normalize_node_id(name1), normalize_node_id(name2)
-        self.emit('%s -> %s [%s];' % (n_from, n_to, ', '.join(sorted(attrs))) )
+        self.emit('%s -> %s [%s];' % (n_from, n_to, ', '.join(sorted(attrs))))
 
     def emit_node(self, name, **props):
         """emit a node with given properties.
@@ -153,74 +137,6 @@ def normalize_node_id(nid):
     """Returns a suitable DOT node id for `nid`."""
     return '"%s"' % nid
 
-class GraphGenerator:
-    def __init__(self, backend):
-        # the backend is responsible to output the graph in a particular format
-        self.backend = backend
-
-    # XXX doesn't like space in outpufile / mapfile
-    def generate(self, visitor, propshdlr, outputfile=None, mapfile=None):
-        # the visitor
-        # the property handler is used to get node and edge properties
-        # according to the graph and to the backend
-        self.propshdlr = propshdlr
-        for nodeid, node in visitor.nodes():
-            props = propshdlr.node_properties(node)
-            self.backend.emit_node(nodeid, **props)
-        for subjnode, objnode, edge in visitor.edges():
-            props = propshdlr.edge_properties(edge, subjnode, objnode)
-            self.backend.emit_edge(subjnode, objnode, **props)
-        return self.backend.generate(outputfile=outputfile, mapfile=mapfile)
-
-
-class UnorderableGraph(Exception):
-    pass
-
-def ordered_nodes(graph):
-    """takes a dependency graph dict as arguments and return an ordered tuple of
-    nodes starting with nodes without dependencies and up to the outermost node.
-
-    If there is some cycle in the graph, :exc:`UnorderableGraph` will be raised.
-
-    Also the given graph dict will be emptied.
-    """
-    # check graph consistency
-    cycles = get_cycles(graph)
-    if cycles:
-        cycles = '\n'.join([' -> '.join(cycle) for cycle in cycles])
-        raise UnorderableGraph('cycles in graph: %s' % cycles)
-    vertices = set(graph)
-    to_vertices = set()
-    for edges in graph.values():
-        to_vertices |= set(edges)
-    missing_vertices = to_vertices - vertices
-    if missing_vertices:
-        raise UnorderableGraph('missing vertices: %s' % ', '.join(missing_vertices))
-    # order vertices
-    order = []
-    order_set = set()
-    old_len = None
-    while graph:
-        if old_len == len(graph):
-            raise UnorderableGraph('unknown problem with %s' % graph)
-        old_len = len(graph)
-        deps_ok = []
-        for node, node_deps in graph.items():
-            for dep in node_deps:
-                if dep not in order_set:
-                    break
-            else:
-                deps_ok.append(node)
-        order.append(deps_ok)
-        order_set |= set(deps_ok)
-        for node in deps_ok:
-            del graph[node]
-    result = []
-    for grp in reversed(order):
-        result.extend(sorted(grp))
-    return tuple(result)
-
-
 def get_cycles(graph_dict, vertices=None):
     '''given a dictionary representing an ordered graph (i.e. key are vertices
     and values is a list of destination vertices representing edges), return a
@@ -248,7 +164,7 @@ def _get_cycles(graph_dict, path, visited, result, vertice):
         index = cycle.index(start_from)
         cycle = cycle[index:] + cycle[0:index]
         # append it to result if not already in
-        if not cycle in result:
+        if cycle not in result:
             result.append(cycle)
         return
     path.append(vertice)
@@ -261,22 +177,3 @@ def _get_cycles(graph_dict, path, visited, result, vertice):
     except KeyError:
         pass
     path.pop()
-
-def has_path(graph_dict, fromnode, tonode, path=None):
-    """generic function taking a simple graph definition as a dictionary, with
-    node has key associated to a list of nodes directly reachable from it.
-
-    Return None if no path exists to go from `fromnode` to `tonode`, else the
-    first path found (as a list including the destination node at last)
-    """
-    if path is None:
-        path = []
-    elif fromnode in path:
-        return None
-    path.append(fromnode)
-    for destnode in graph_dict[fromnode]:
-        if destnode == tonode or has_path(graph_dict, destnode, tonode, path):
-            return path[1:] + [tonode]
-    path.pop()
-    return None
-