libv8 7.8.279.23.0beta1 → 8.4.255.0

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

@@ -1,181 +0,0 @@
-# -*- coding: utf-8; mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4
-# -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
-# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
-# http://www.logilab.fr/ -- mailto:contact@logilab.fr
-#
-# 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.
-"""Emacs and Flymake compatible Pylint.
-
-This script is for integration with emacs and is compatible with flymake mode.
-
-epylint walks out of python packages before invoking pylint. This avoids
-reporting import errors that occur when a module within a package uses the
-absolute import path to get another module within this package.
-
-For example:
-    - Suppose a package is structured as
-
-        a/__init__.py
-        a/b/x.py
-        a/c/y.py
-
-   - Then if y.py imports x as "from a.b import x" the following produces pylint
-     errors
-
-       cd a/c; pylint y.py
-
-   - The following obviously doesn't
-
-       pylint a/c/y.py
-
-   - As this script will be invoked by emacs within the directory of the file
-     we are checking we need to go out of it to avoid these false positives.
-
-
-You may also use py_run to run pylint with desired options and get back (or not)
-its output.
-"""
-from __future__ import print_function
-
-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.'''
-    env = dict(os.environ)
-    env['PYTHONPATH'] = os.pathsep.join(sys.path)
-    return env
-
-def lint(filename, options=None):
-    """Pylint the given file.
-
-    When run from emacs we will be in the directory of a file, and passed its
-    filename.  If this file is part of a package and is trying to import other
-    modules from within its own package or another package rooted in a directory
-    below it, pylint will classify it as a failed import.
-
-    To get around this, we traverse down the directory tree to find the root of
-    the package this module is in.  We then invoke pylint from this directory.
-
-    Finally, we must correct the filenames in the output generated by pylint so
-    Emacs doesn't become confused (it will expect just the original filename,
-    while pylint may extend it with extra directories if we've traversed down
-    the tree)
-    """
-    # traverse downwards until we are out of a python package
-    full_path = osp.abspath(filename)
-    parent_path = osp.dirname(full_path)
-    child_path = osp.basename(full_path)
-
-    while parent_path != "/" and osp.exists(osp.join(parent_path, '__init__.py')):
-        child_path = osp.join(osp.basename(parent_path), child_path)
-        parent_path = osp.dirname(parent_path)
-
-    # Start pylint
-    # Ensure we use the python and pylint associated with the running epylint
-    from pylint import lint as lint_mod
-    lint_path = lint_mod.__file__
-    options = options or ['--disable=C,R,I']
-    cmd = [sys.executable, lint_path] + options + [
-        '--msg-template', '{path}:{line}: {category} ({msg_id}, {symbol}, {obj}) {msg}',
-        '-r', 'n', child_path]
-    process = Popen(cmd, stdout=PIPE, cwd=parent_path, env=_get_env(),
-                    universal_newlines=True)
-
-    for line in process.stdout:
-        # remove pylintrc warning
-        if line.startswith("No config file found"):
-            continue
-
-        # modify the file name thats output to reverse the path traversal we made
-        parts = line.split(":")
-        if parts and parts[0] == child_path:
-            line = ":".join([filename] + parts[1:])
-        print(line, end=' ')
-
-    process.wait()
-    return process.returncode
-
-
-def py_run(command_options='', return_std=False, stdout=None, stderr=None,
-           script='epylint'):
-    """Run pylint from python
-
-    ``command_options`` is a string containing ``pylint`` command line options;
-    ``return_std`` (boolean) indicates return of created standard output
-    and error (see below);
-    ``stdout`` and ``stderr`` are 'file-like' objects in which standard output
-    could be written.
-
-    Calling agent is responsible for stdout/err management (creation, close).
-    Default standard output and error are those from sys,
-    or standalone ones (``subprocess.PIPE``) are used
-    if they are not set and ``return_std``.
-
-    If ``return_std`` is set to ``True``, this function returns a 2-uple
-    containing standard output and error related to created process,
-    as follows: ``(stdout, stderr)``.
-
-    A trivial usage could be as follows:
-        >>> py_run( '--version')
-        No config file found, using default configuration
-        pylint 0.18.1,
-            ...
-
-    To silently run Pylint on a module, and get its standard output and error:
-        >>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True)
-    """
-    # Create command line to call pylint
-    if os.name == 'nt':
-        script += '.bat'
-    command_line = script + ' ' + command_options
-    # Providing standard output and/or error if not set
-    if stdout is None:
-        if return_std:
-            stdout = PIPE
-        else:
-            stdout = sys.stdout
-    if stderr is None:
-        if return_std:
-            stderr = PIPE
-        else:
-            stderr = sys.stderr
-    # Call pylint in a subprocess
-    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 six.moves.StringIO(proc_stdout), six.moves.StringIO(proc_stderr)
-
-
-def Run():
-    if len(sys.argv) == 1:
-        print("Usage: %s <filename> [options]" % sys.argv[0])
-        sys.exit(1)
-    elif not osp.exists(sys.argv[1]):
-        print("%s does not exist" % sys.argv[1])
-        sys.exit(1)
-    else:
-        sys.exit(lint(sys.argv[1], sys.argv[2:]))
-
-
-if __name__ == '__main__':
-    Run()

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

@@ -1,311 +0,0 @@
-"""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))