libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/pylint/checkers/format.py

@@ -60,7 +60,9 @@ _IGNORE = 2
 # Whitespace checking config constants
 _DICT_SEPARATOR = 'dict-separator'
 _TRAILING_COMMA = 'trailing-comma'
-_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR]
+_EMPTY_LINE = 'empty-line'
+_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR, _EMPTY_LINE]
+_DEFAULT_NO_SPACE_CHECK_CHOICES = [_TRAILING_COMMA, _DICT_SEPARATOR]
 
 MSGS = {
     'C0301': ('Line too long (%s/%s)',
@@ -81,7 +83,7 @@ MSGS = {
               'bad-indentation',
               'Used when an unexpected number of indentation\'s tabulations or '
               'spaces has been found.'),
-    'C0330': ('Wrong %s indentation%s.\n%s%s',
+    'C0330': ('Wrong %s indentation%s%s.\n%s%s',
               'bad-continuation',
               'TODO'),
     'W0312': ('Found indentation with %ss instead of %ss',
@@ -124,8 +126,11 @@ MSGS = {
 def _underline_token(token):
     length = token[3][1] - token[2][1]
     offset = token[2][1]
-    return token[4] + (' ' * offset) + ('^' * length)
-
+    referenced_line = token[4]
+    # If the referenced line does not end with a newline char, fix it
+    if referenced_line[-1] != '\n':
+        referenced_line += '\n'
+    return referenced_line + (' ' * offset) + ('^' * length)
 
 def _column_distance(token1, token2):
     if token1 == token2:
@@ -165,14 +170,22 @@ def _get_indent_length(line):
 def _get_indent_hint_line(bar_positions, bad_position):
     """Return a line with |s for each of the positions in the given lists."""
     if not bar_positions:
-        return ''
+        return ('', '')
+    delta_message = ''
     markers = [(pos, '|') for pos in bar_positions]
+    if len(markers) == 1:
+        # if we have only one marker we'll provide an extra hint on how to fix
+        expected_position = markers[0][0]
+        delta = abs(expected_position - bad_position)
+        direction = 'add' if expected_position > bad_position else 'remove'
+        delta_message = _CONTINUATION_HINT_MESSAGE % (
+            direction, delta, 's' if delta > 1 else '')
     markers.append((bad_position, '^'))
     markers.sort()
     line = [' '] * (markers[-1][0] + 1)
     for position, marker in markers:
         line[position] = marker
-    return ''.join(line)
+    return (''.join(line), delta_message)
 
 
 class _ContinuedIndent(object):
@@ -218,6 +231,7 @@ _CONTINUATION_MSG_PARTS = {
     CONTINUED_BLOCK: ('continued', ' before block'),
 }
 
+_CONTINUATION_HINT_MESSAGE = ' (%s %d space%s)'  # Ex: (remove 2 spaces)
 
 def _Offsets(*args):
     """Valid indentation offsets for a continued line."""
@@ -423,11 +437,17 @@ class FormatChecker(BaseTokenChecker):
                  'help' : ('Allow the body of an if to be on the same '
                            'line as the test if there is no else.')}),
                ('no-space-check',
-                {'default': ','.join(_NO_SPACE_CHECK_CHOICES),
+                {'default': ','.join(_DEFAULT_NO_SPACE_CHECK_CHOICES),
+                 'metavar': ','.join(_NO_SPACE_CHECK_CHOICES),
                  'type': 'multiple_choice',
                  'choices': _NO_SPACE_CHECK_CHOICES,
                  'help': ('List of optional constructs for which whitespace '
-                          'checking is disabled')}),
+                          'checking is disabled. '
+                          '`'+ _DICT_SEPARATOR + '` is used to allow tabulation '
+                          'in dicts, etc.: {1  : 1,\\n222: 2}. '
+                          '`'+ _TRAILING_COMMA + '` allows a space between comma '
+                          'and closing bracket: (a, ). '
+                          '`'+ _EMPTY_LINE + '` allows space-only lines.')}),
                ('max-module-lines',
                 {'default' : 1000, 'type' : 'int', 'metavar' : '<int>',
                  'help': 'Maximum number of lines in a module'}
@@ -510,27 +530,28 @@ class FormatChecker(BaseTokenChecker):
                 depth += 1
             elif token[1] == ')':
                 depth -= 1
-                if not depth:
-                    # ')' can't happen after if (foo), since it would be a syntax error.
-                    if (tokens[i+1][1] in (':', ')', ']', '}', 'in') or
-                            tokens[i+1][0] in (tokenize.NEWLINE,
-                                               tokenize.ENDMARKER,
-                                               tokenize.COMMENT)):
-                        # The empty tuple () is always accepted.
-                        if i == start + 2:
-                            return
-                        if keyword_token == 'not':
-                            if not found_and_or:
-                                self.add_message('superfluous-parens', line=line_num,
-                                                 args=keyword_token)
-                        elif keyword_token in ('return', 'yield'):
+                if depth:
+                    continue
+                # ')' can't happen after if (foo), since it would be a syntax error.
+                if (tokens[i+1][1] in (':', ')', ']', '}', 'in') or
+                        tokens[i+1][0] in (tokenize.NEWLINE,
+                                           tokenize.ENDMARKER,
+                                           tokenize.COMMENT)):
+                    # The empty tuple () is always accepted.
+                    if i == start + 2:
+                        return
+                    if keyword_token == 'not':
+                        if not found_and_or:
                             self.add_message('superfluous-parens', line=line_num,
                                              args=keyword_token)
-                        elif keyword_token not in self._keywords_with_parens:
-                            if not (tokens[i+1][1] == 'in' and found_and_or):
-                                self.add_message('superfluous-parens', line=line_num,
-                                                 args=keyword_token)
-                    return
+                    elif keyword_token in ('return', 'yield'):
+                        self.add_message('superfluous-parens', line=line_num,
+                                         args=keyword_token)
+                    elif keyword_token not in self._keywords_with_parens:
+                        if not (tokens[i+1][1] == 'in' and found_and_or):
+                            self.add_message('superfluous-parens', line=line_num,
+                                             args=keyword_token)
+                return
             elif depth == 1:
                 # This is a tuple, which is always acceptable.
                 if token[1] == ',':
@@ -846,11 +867,12 @@ class FormatChecker(BaseTokenChecker):
 
     def _add_continuation_message(self, state, offsets, tokens, position):
         readable_type, readable_position = _CONTINUATION_MSG_PARTS[state.context_type]
-        hint_line = _get_indent_hint_line(offsets, tokens.start_col(position))
+        hint_line, delta_message = _get_indent_hint_line(offsets, tokens.start_col(position))
         self.add_message(
             'bad-continuation',
             line=tokens.start_line(position),
-            args=(readable_type, readable_position, tokens.line(position), hint_line))
+            args=(readable_type, readable_position, delta_message,
+                  tokens.line(position), hint_line))
 
     @check_messages('multiple-statements')
     def visit_default(self, node):
@@ -920,7 +942,10 @@ class FormatChecker(BaseTokenChecker):
                 self.add_message('missing-final-newline', line=i)
             else:
                 stripped_line = line.rstrip()
-                if line[len(stripped_line):] not in ('\n', '\r\n'):
+                if not stripped_line and _EMPTY_LINE in self.config.no_space_check:
+                    # allow empty lines
+                    pass
+                elif line[len(stripped_line):] not in ('\n', '\r\n'):
                     self.add_message('trailing-whitespace', line=i)
                 # Don't count excess whitespace in the line length.
                 line = stripped_line

data/vendor/depot_tools/third_party/pylint/checkers/imports.py

@@ -15,34 +15,56 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """imports checkers for Python code"""
 
+import collections
+from distutils import sysconfig
+import os
 import sys
-from collections import defaultdict
 
 import six
-from six.moves import map # pylint: disable=redefined-builtin
-
-from logilab.common.graph import get_cycles, DotBackend
-from logilab.common.ureports import VerbatimText, Paragraph
 
 import astroid
 from astroid import are_exclusive
-from astroid.modutils import get_module_part, is_standard_module
+from astroid.modutils import (get_module_part, is_standard_module,
+                              file_from_modpath)
 
 from pylint.interfaces import IAstroidChecker
-from pylint.utils import EmptyReport
+from pylint.utils import EmptyReport, get_global_option
 from pylint.checkers import BaseChecker
-from pylint.checkers.utils import check_messages, is_import_error
+from pylint.checkers.utils import check_messages, node_ignores_exception
+from pylint.graph import get_cycles, DotBackend
+from pylint.reporters.ureports.nodes import VerbatimText, Paragraph
+
+
+def _qualified_names(modname):
+    """Split the names of the given module into subparts
 
-def _except_import_error(node):
+    For example,
+        _qualified_names('pylint.checkers.ImportsChecker')
+    returns
+        ['pylint', 'pylint.checkers', 'pylint.checkers.ImportsChecker']
     """
-    Check if the try-except node has an ImportError handler.
-    Return True if an ImportError handler was infered, False otherwise.
+    names = modname.split('.')
+    return ['.'.join(names[0:i+1]) for i in range(len(names))]
+
+
+def _get_import_name(importnode, modname):
+    """Get a prepared module name from the given import node
+
+    In the case of relative imports, this will return the
+    absolute qualified module name, which might be useful
+    for debugging. Otherwise, the initial module name
+    is returned unchanged.
     """
-    if not isinstance(node, astroid.TryExcept):
-        return
-    return any(map(is_import_error, node.handlers))
+    if isinstance(importnode, astroid.ImportFrom):
+        if importnode.level:
+            root = importnode.root()
+            if isinstance(root, astroid.Module):
+                modname = root.relative_to_absolute_name(
+                    modname, level=importnode.level)
+    return modname
+
 
-def get_first_import(node, context, name, base, level):
+def _get_first_import(node, context, name, base, level):
     """return the node where [base.]<name> is imported or None if not found
     """
     fullname = '%s.%s' % (base, name) if base else name
@@ -58,7 +80,7 @@ def get_first_import(node, context, name, base, level):
             if any(fullname == iname[0] for iname in first.names):
                 found = True
                 break
-        elif isinstance(first, astroid.From):
+        elif isinstance(first, astroid.ImportFrom):
             if level == first.level and any(
                     fullname == '%s.%s' % (first.modname, iname[0])
                     for iname in first.names):
@@ -69,7 +91,7 @@ def get_first_import(node, context, name, base, level):
 
 # utilities to represents import dependencies as tree and dot graph ###########
 
-def make_tree_defs(mod_files_list):
+def _make_tree_defs(mod_files_list):
     """get a list of 2-uple (module, list_of_files_which_import_this_module),
     it will return a dictionary to represent this as a tree
     """
@@ -81,7 +103,8 @@ def make_tree_defs(mod_files_list):
         node[1] += files
     return tree_defs
 
-def repr_tree_defs(data, indent_str=None):
+
+def _repr_tree_defs(data, indent_str=None):
     """return a string which represents imports as a tree"""
     lines = []
     nodes = data.items()
@@ -100,11 +123,11 @@ def repr_tree_defs(data, indent_str=None):
             else:
                 sub_indent_str = '%s| ' % indent_str
         if sub:
-            lines.append(repr_tree_defs(sub, sub_indent_str))
+            lines.append(_repr_tree_defs(sub, sub_indent_str))
     return '\n'.join(lines)
 
 
-def dependencies_graph(filename, dep_info):
+def _dependencies_graph(filename, dep_info):
     """write dependencies as a dot (graphviz) file
     """
     done = {}
@@ -123,11 +146,11 @@ def dependencies_graph(filename, dep_info):
     printer.generate(filename)
 
 
-def make_graph(filename, dep_info, sect, gtype):
+def _make_graph(filename, dep_info, sect, gtype):
     """generate a dependencies graph and add some information about it in the
     report's section
     """
-    dependencies_graph(filename, dep_info)
+    _dependencies_graph(filename, dep_info)
     sect.append(Paragraph('%simports graph has been written to %s'
                           % (gtype, filename)))
 
@@ -135,9 +158,10 @@ def make_graph(filename, dep_info, sect, gtype):
 # the import checker itself ###################################################
 
 MSGS = {
-    'F0401': ('Unable to import %s',
+    'E0401': ('Unable to import %s',
               'import-error',
-              'Used when pylint has been unable to import a module.'),
+              'Used when pylint has been unable to import a module.',
+              {'old_names': [('F0401', 'import-error')]}),
     'R0401': ('Cyclic import (%s)',
               'cyclic-import',
               'Used when a cyclic import between two or more modules is \
@@ -164,8 +188,23 @@ MSGS = {
     'W0410': ('__future__ import is not the first non docstring statement',
               'misplaced-future',
               'Python 2.5 and greater require __future__ import to be the \
-              first non docstring statement in the module.',
-              {'maxversion': (3, 0)}),
+              first non docstring statement in the module.'),
+
+    'C0410': ('Multiple imports on one line (%s)',
+              'multiple-imports',
+              'Used when import statement importing multiple modules is '
+              'detected.'),
+    'C0411': ('%s comes before %s',
+              'wrong-import-order',
+              'Used when PEP8 import order is not respected (standard imports '
+              'first, then third-party libraries, then local imports)'),
+    'C0412': ('Imports from package %s are not grouped',
+              'ungrouped-imports',
+              'Used when imports are not grouped by packages'),
+    'C0413': ('Import "%s" should be placed at the top of the '
+              'module',
+              'wrong-import-position',
+              'Used when code and imports are mixed'),
     }
 
 class ImportsChecker(BaseChecker):
@@ -182,10 +221,10 @@ class ImportsChecker(BaseChecker):
     msgs = MSGS
     priority = -2
 
-    if sys.version_info < (3,):
+    if six.PY2:
         deprecated_modules = ('regsub', 'TERMIOS', 'Bastion', 'rexec')
     else:
-        deprecated_modules = ('stringprep', 'optparse')
+        deprecated_modules = ('optparse', )
     options = (('deprecated-modules',
                 {'default' : deprecated_modules,
                  'type' : 'csv',
@@ -220,19 +259,46 @@ given file (report RP0402 must not be disabled)'}
         BaseChecker.__init__(self, linter)
         self.stats = None
         self.import_graph = None
+        self._imports_stack = []
+        self._first_non_import_node = None
         self.__int_dep_info = self.__ext_dep_info = None
         self.reports = (('RP0401', 'External dependencies',
-                         self.report_external_dependencies),
+                         self._report_external_dependencies),
                         ('RP0402', 'Modules dependencies graph',
-                         self.report_dependencies_graph),
+                         self._report_dependencies_graph),
                        )
 
+        self._site_packages = self._compute_site_packages()
+
+    @staticmethod
+    def _compute_site_packages():
+        def _normalized_path(path):
+            return os.path.normcase(os.path.abspath(path))
+
+        paths = set()
+        real_prefix = getattr(sys, 'real_prefix', None)
+        for prefix in filter(None, (real_prefix, sys.prefix)):
+            path = sysconfig.get_python_lib(prefix=prefix)
+            path = _normalized_path(path)
+            paths.add(path)
+
+        # Handle Debian's derivatives /usr/local.
+        if os.path.isfile("/etc/debian_version"):
+            for prefix in filter(None, (real_prefix, sys.prefix)):
+                libpython = os.path.join(prefix, "local", "lib",
+                                         "python" + sysconfig.get_python_version(),
+                                         "dist-packages")
+                paths.add(libpython)
+        return paths
+
     def open(self):
         """called before visiting project (i.e set of modules)"""
         self.linter.add_stats(dependencies={})
         self.linter.add_stats(cycles=[])
         self.stats = self.linter.stats
-        self.import_graph = defaultdict(set)
+        self.import_graph = collections.defaultdict(set)
+        self._ignored_modules = get_global_option(
+            self, 'ignored-modules', default=[])
 
     def close(self):
         """called before visiting project (i.e set of modules)"""
@@ -242,56 +308,211 @@ given file (report RP0402 must not be disabled)'}
             for cycle in get_cycles(self.import_graph, vertices=vertices):
                 self.add_message('cyclic-import', args=' -> '.join(cycle))
 
+    @check_messages('wrong-import-position', 'multiple-imports',
+                    'relative-import', 'reimported')
     def visit_import(self, node):
         """triggered when an import statement is seen"""
+        self._check_reimport(node)
+
         modnode = node.root()
-        for name, _ in node.names:
+        names = [name for name, _ in node.names]
+        if len(names) >= 2:
+            self.add_message('multiple-imports', args=', '.join(names), node=node)
+
+        for name in names:
+            self._check_deprecated_module(node, name)
             importedmodnode = self.get_imported_module(node, name)
+            if isinstance(node.scope(), astroid.Module):
+                self._check_position(node)
+                self._record_import(node, importedmodnode)
+
             if importedmodnode is None:
                 continue
+
             self._check_relative_import(modnode, node, importedmodnode, name)
             self._add_imported_module(node, importedmodnode.name)
-            self._check_deprecated_module(node, name)
-            self._check_reimport(node, name)
 
-    # TODO This appears to be the list of all messages of the checker...
-    # @check_messages('W0410', 'W0401', 'W0403', 'W0402', 'W0404', 'W0406', 'F0401')
     @check_messages(*(MSGS.keys()))
-    def visit_from(self, node):
+    def visit_importfrom(self, node):
         """triggered when a from statement is seen"""
         basename = node.modname
-        if basename == '__future__':
-            # check if this is the first non-docstring statement in the module
-            prev = node.previous_sibling()
-            if prev:
-                # consecutive future statements are possible
-                if not (isinstance(prev, astroid.From)
-                        and prev.modname == '__future__'):
-                    self.add_message('misplaced-future', node=node)
-            return
-        for name, _ in node.names:
-            if name == '*':
-                self.add_message('wildcard-import', args=basename, node=node)
+        self._check_misplaced_future(node)
+        self._check_deprecated_module(node, basename)
+        self._check_wildcard_imports(node)
+        self._check_same_line_imports(node)
+        self._check_reimport(node, basename=basename, level=node.level)
+
         modnode = node.root()
         importedmodnode = self.get_imported_module(node, basename)
+        if isinstance(node.scope(), astroid.Module):
+            self._check_position(node)
+            self._record_import(node, importedmodnode)
         if importedmodnode is None:
             return
         self._check_relative_import(modnode, node, importedmodnode, basename)
-        self._check_deprecated_module(node, basename)
+
         for name, _ in node.names:
             if name != '*':
                 self._add_imported_module(node, '%s.%s' % (importedmodnode.name, name))
-                self._check_reimport(node, name, basename, node.level)
+
+    @check_messages('wrong-import-order', 'ungrouped-imports',
+                    'wrong-import-position')
+    def leave_module(self, node):
+        # Check imports are grouped by category (standard, 3rd party, local)
+        std_imports, ext_imports, loc_imports = self._check_imports_order(node)
+
+        # Check imports are grouped by package within a given category
+        met = set()
+        current_package = None
+        for import_node, import_name in std_imports + ext_imports + loc_imports:
+            package, _, _ = import_name.partition('.')
+            if current_package and current_package != package and package in met:
+                self.add_message('ungrouped-imports', node=import_node,
+                                 args=package)
+            current_package = package
+            met.add(package)
+
+        self._imports_stack = []
+        self._first_non_import_node = None
+
+    def visit_if(self, node):
+        # if the node does not contain an import instruction, and if it is the
+        # first node of the module, keep a track of it (all the import positions
+        # of the module will be compared to the position of this first
+        # instruction)
+        if self._first_non_import_node:
+            return
+        if not isinstance(node.parent, astroid.Module):
+            return
+        if any(node.nodes_of_class((astroid.Import, astroid.ImportFrom))):
+            return
+        self._first_non_import_node = node
+
+    visit_tryfinally = visit_tryexcept = visit_assignattr = visit_assign \
+            = visit_ifexp = visit_comprehension = visit_if
+
+    def visit_functiondef(self, node):
+        # If it is the first non import instruction of the module, record it.
+        if self._first_non_import_node:
+            return
+
+        # Check if the node belongs to an `If` or a `Try` block. If they
+        # contain imports, skip recording this node.
+        if not isinstance(node.parent.scope(), astroid.Module):
+            return
+
+        root = node
+        while not isinstance(root.parent, astroid.Module):
+            root = root.parent
+
+        if isinstance(root, (astroid.If, astroid.TryFinally, astroid.TryExcept)):
+            if any(root.nodes_of_class((astroid.Import, astroid.ImportFrom))):
+                return
+
+        self._first_non_import_node = node
+
+    visit_classdef = visit_for = visit_while = visit_functiondef
+
+    def _check_misplaced_future(self, node):
+        basename = node.modname
+        if basename == '__future__':
+            # check if this is the first non-docstring statement in the module
+            prev = node.previous_sibling()
+            if prev:
+                # consecutive future statements are possible
+                if not (isinstance(prev, astroid.ImportFrom)
+                        and prev.modname == '__future__'):
+                    self.add_message('misplaced-future', node=node)
+            return
+
+    def _check_same_line_imports(self, node):
+        # Detect duplicate imports on the same line.
+        names = (name for name, _ in node.names)
+        counter = collections.Counter(names)
+        for name, count in counter.items():
+            if count > 1:
+                self.add_message('reimported', node=node,
+                                 args=(name, node.fromlineno))
+
+    def _check_position(self, node):
+        """Check `node` import or importfrom node position is correct
+
+        Send a message  if `node` comes before another instruction
+        """
+        # if a first non-import instruction has already been encountered,
+        # it means the import comes after it and therefore is not well placed
+        if self._first_non_import_node:
+            self.add_message('wrong-import-position', node=node,
+                             args=node.as_string())
+
+    def _record_import(self, node, importedmodnode):
+        """Record the package `node` imports from"""
+        importedname = importedmodnode.name if importedmodnode else None
+        if not importedname:
+            importedname = node.names[0][0].split('.')[0]
+        self._imports_stack.append((node, importedname))
+
+    @staticmethod
+    def _is_fallback_import(node, imports):
+        imports = [import_node for (import_node, _) in imports]
+        return any(astroid.are_exclusive(import_node, node)
+                   for import_node in imports)
+
+    def _check_imports_order(self, node):
+        """Checks imports of module `node` are grouped by category
+
+        Imports must follow this order: standard, 3rd party, local
+        """
+        extern_imports = []
+        local_imports = []
+        std_imports = []
+        for node, modname in self._imports_stack:
+            package = modname.split('.')[0]
+            if is_standard_module(modname):
+                std_imports.append((node, package))
+                wrong_import = extern_imports or local_imports
+                if not wrong_import:
+                    continue
+                if self._is_fallback_import(node, wrong_import):
+                    continue
+                self.add_message('wrong-import-order', node=node,
+                                 args=('standard import "%s"' % node.as_string(),
+                                       '"%s"' % wrong_import[0][0].as_string()))
+            else:
+                try:
+                    filename = file_from_modpath([package])
+                except ImportError:
+                    continue
+                if not filename:
+                    continue
+
+                filename = os.path.normcase(os.path.abspath(filename))
+                if not any(filename.startswith(path) for path in self._site_packages):
+                    local_imports.append((node, package))
+                    continue
+                extern_imports.append((node, package))
+                if not local_imports:
+                    continue
+                self.add_message('wrong-import-order', node=node,
+                                 args=('external import "%s"' % node.as_string(),
+                                       '"%s"' % local_imports[0][0].as_string()))
+        return std_imports, extern_imports, local_imports
 
     def get_imported_module(self, importnode, modname):
         try:
             return importnode.do_import_module(modname)
         except astroid.InferenceError as ex:
+            dotted_modname = _get_import_name(importnode, modname)
             if str(ex) != modname:
-                args = '%r (%s)' % (modname, ex)
+                args = '%r (%s)' % (dotted_modname, ex)
             else:
-                args = repr(modname)
-            if not _except_import_error(importnode.parent):
+                args = repr(dotted_modname)
+
+            for submodule in _qualified_names(modname):
+                if submodule in self._ignored_modules:
+                    return None
+
+            if not node_ignores_exception(importnode, ImportError):
                 self.add_message("import-error", args=args, node=importnode)
 
     def _check_relative_import(self, modnode, importnode, importedmodnode,
@@ -315,19 +536,32 @@ given file (report RP0402 must not be disabled)'}
 
     def _add_imported_module(self, node, importedmodname):
         """notify an imported module, used to analyze dependencies"""
+        module_file = node.root().file
+        context_name = node.root().name
+        base = os.path.splitext(os.path.basename(module_file))[0]
+
+        # Determine if we have a `from .something import` in a package's
+        # __init__. This means the module will never be able to import
+        # itself using this condition (the level will be bigger or
+        # if the same module is named as the package, it will be different
+        # anyway).
+        if isinstance(node, astroid.ImportFrom):
+            if node.level and node.level > 0 and base == '__init__':
+                return
+
         try:
-            importedmodname = get_module_part(importedmodname)
+            importedmodname = get_module_part(importedmodname,
+                                              module_file)
         except ImportError:
             pass
-        context_name = node.root().name
+
         if context_name == importedmodname:
-            # module importing itself !
             self.add_message('import-self', node=node)
         elif not is_standard_module(importedmodname):
             # handle dependencies
             importedmodnames = self.stats['dependencies'].setdefault(
                 importedmodname, set())
-            if not context_name in importedmodnames:
+            if context_name not in importedmodnames:
                 importedmodnames.add(context_name)
             # update import graph
             mgraph = self.import_graph[context_name]
@@ -340,31 +574,33 @@ given file (report RP0402 must not be disabled)'}
             if mod_path == mod_name or mod_path.startswith(mod_name + '.'):
                 self.add_message('deprecated-module', node=node, args=mod_path)
 
-    def _check_reimport(self, node, name, basename=None, level=None):
+    def _check_reimport(self, node, basename=None, level=None):
         """check if the import is necessary (i.e. not already done)"""
         if not self.linter.is_message_enabled('reimported'):
             return
+
         frame = node.frame()
         root = node.root()
         contexts = [(frame, level)]
         if root is not frame:
             contexts.append((root, None))
-        for context, level in contexts:
-            first = get_first_import(node, context, name, basename, level)
-            if first is not None:
-                self.add_message('reimported', node=node,
-                                 args=(name, first.fromlineno))
 
+        for context, level in contexts:
+            for name, _ in node.names:
+                first = _get_first_import(node, context, name, basename, level)
+                if first is not None:
+                    self.add_message('reimported', node=node,
+                                     args=(name, first.fromlineno))
 
-    def report_external_dependencies(self, sect, _, dummy):
+    def _report_external_dependencies(self, sect, _, dummy):
         """return a verbatim layout for displaying dependencies"""
-        dep_info = make_tree_defs(six.iteritems(self._external_dependencies_info()))
+        dep_info = _make_tree_defs(six.iteritems(self._external_dependencies_info()))
         if not dep_info:
             raise EmptyReport()
-        tree_str = repr_tree_defs(dep_info)
+        tree_str = _repr_tree_defs(dep_info)
         sect.append(VerbatimText(tree_str))
 
-    def report_dependencies_graph(self, sect, _, dummy):
+    def _report_dependencies_graph(self, sect, _, dummy):
         """write dependencies as a dot (graphviz) file"""
         dep_info = self.stats['dependencies']
         if not dep_info or not (self.config.import_graph
@@ -373,15 +609,15 @@ given file (report RP0402 must not be disabled)'}
             raise EmptyReport()
         filename = self.config.import_graph
         if filename:
-            make_graph(filename, dep_info, sect, '')
+            _make_graph(filename, dep_info, sect, '')
         filename = self.config.ext_import_graph
         if filename:
-            make_graph(filename, self._external_dependencies_info(),
-                       sect, 'external ')
+            _make_graph(filename, self._external_dependencies_info(),
+                        sect, 'external ')
         filename = self.config.int_import_graph
         if filename:
-            make_graph(filename, self._internal_dependencies_info(),
-                       sect, 'internal ')
+            _make_graph(filename, self._internal_dependencies_info(),
+                        sect, 'internal ')
 
     def _external_dependencies_info(self):
         """return cached external dependencies information or build and
@@ -407,6 +643,11 @@ given file (report RP0402 must not be disabled)'}
                     result[importee] = importers
         return self.__int_dep_info
 
+    def _check_wildcard_imports(self, node):
+        for name, _ in node.names:
+            if name == '*':
+                self.add_message('wildcard-import', args=node.modname, node=node)
+
 
 def register(linter):
     """required method to auto register this checker """