def test_for_while_lineno(self):
for code in (
'''
for a in range(4):
print (a)
break
else:
print ("bouh")
''',
'''
while a:
print (a)
break
else:
print ("bouh")
''',
):
astroid = builder.AstroidBuilder().string_build(
code, __name__, __file__)
stmt = astroid.body[0]
self.assertEqual(stmt.fromlineno, 2)
self.assertEqual(stmt.tolineno, 6)
self.assertEqual(stmt.blockstart_tolineno, 2)
self.assertEqual(stmt.orelse[0].fromlineno, 6) # XXX
self.assertEqual(stmt.orelse[0].tolineno, 6)
def test_build_from_live_module_without_source_file(self) -> None:
"""Assert that inspect_build() is not called.
See comment in module_build() before the call to inspect_build():
"get a partial representation by introspection"
This "partial representation" was presumably causing unexpected behavior.
"""
# Sanity check
self.assertIsNone(
self.imported_module.__loader__.get_source(
self.imported_module_path.stem))
with self.assertRaises(AttributeError):
_ = self.imported_module.__file__
my_builder = builder.AstroidBuilder()
with unittest.mock.patch.object(
self.imported_module.__loader__,
"get_source",
return_value=self.code_snippet,
):
with unittest.mock.patch.object(my_builder,
"inspect_build",
side_effect=AssertionError):
my_builder.module_build(self.imported_module,
modname=self.imported_module_path.stem)
def __init__(self, view, document):
self._view = view
self._document = document
# icon, name, class_name, line_no, docstring
Gtk.TreeStore.__init__(self, GdkPixbuf.Pixbuf, str, str, int, str)
if not builder:
self.append(None, [
self.errorIcon, 'logilab.astng missing or invalid', None, -1,
None
])
return
start, end = document.get_bounds()
text = document.get_text(start, end, False)
try:
tree = builder.AstroidBuilder().string_build(text)
except Exception as e:
tb = sys.exc_info()[2]
lineno = tb.tb_lineno - 1
self.append(None, [
self.errorIcon,
'%s\n\t%s' % (e.__class__.__name__, str(e)), None, lineno - 1,
self._docstring_error(e)
])
return
for n in tree.body:
self.append_member(n)
def test_stream_api(self):
path = resources.find('data/all.py')
astroid = builder.AstroidBuilder().file_build(path, 'all')
stream = astroid.stream()
self.assertTrue(hasattr(stream, 'close'))
with stream:
with open(path, 'rb') as file_io:
self.assertEqual(stream.read(), file_io.read())
def test_with_lineno(self):
astroid = builder.AstroidBuilder().string_build('''
from __future__ import with_statement
with file("/tmp/pouet") as f:
print (f)
''', __name__, __file__)
with_ = astroid.body[1]
self.assertEqual(with_.fromlineno, 3)
self.assertEqual(with_.tolineno, 4)
self.assertEqual(with_.blockstart_tolineno, 3)
def setUp(self):
super(ModuleBuildTest, self).setUp()
abuilder = builder.AstroidBuilder()
try:
import data.module
except ImportError:
# Make pylint happy.
self.skipTest('Unable to load data.module')
else:
self.module = abuilder.module_build(data.module, 'data.module')
def build_module(code, module_name=''):
"""Parses a string module with a builder.
:param code: The code for the module.
:type code: str
:param module_name: The name for the module
:type module_name: str
:returns: The module AST.
:rtype: astroid.bases.NodeNG
"""
code = textwrap.dedent(code)
return builder.AstroidBuilder(None).string_build(code, modname=module_name)
def test_builder_apply_transforms(self):
def transform_function(node):
return nodes.const_factory(42)
manager = builder.MANAGER
with add_transform(manager, nodes.FunctionDef, transform_function):
astroid_builder = builder.AstroidBuilder(apply_transforms=False)
module = astroid_builder.string_build("""def test(): pass""")
# The transform wasn't applied.
self.assertIsInstance(module.body[0], nodes.FunctionDef)
def web2py_transform(module):
path = module.file
if path is None:
return
if ('controllers' in path or
'views' in path or
'models' in path):
fake = builder.AstroidBuilder(
manager.AstroidManager()).string_build(PREAMBLE)
module.globals.update(fake.locals)
def test_try_finally_lineno(self):
astroid = builder.AstroidBuilder().string_build('''
try:
print (a)
finally:
print ("bouh")
''', __name__, __file__)
try_ = astroid.body[0]
self.assertEqual(try_.fromlineno, 2)
self.assertEqual(try_.tolineno, 5)
self.assertEqual(try_.blockstart_tolineno, 2)
self.assertEqual(try_.finalbody[0].fromlineno, 5) # XXX
self.assertEqual(try_.finalbody[0].tolineno, 5)
def test_decorated_function_lineno(self):
astroid = builder.AstroidBuilder().string_build('''
@decorator
def function(
arg):
print (arg)
''', __name__, __file__)
function = astroid['function']
self.assertEqual(function.fromlineno, 3) # XXX discussable, but that's what is expected by pylint right now
self.assertEqual(function.tolineno, 5)
self.assertEqual(function.decorators.fromlineno, 2)
self.assertEqual(function.decorators.tolineno, 2)
if sys.version_info < (3, 0):
self.assertEqual(function.blockstart_tolineno, 4)
else:
self.skipTest('FIXME http://bugs.python.org/issue10445 '
'(no line number on function args)')
def test_file_stream_api(self):
path = resources.find('data/all.py')
astroid = builder.AstroidBuilder().file_build(path, 'all')
if __pkginfo__.numversion >= (1, 6):
# file_stream is slated for removal in astroid 1.6.
with self.assertRaises(AttributeError):
astroid.file_stream
else:
# Until astroid 1.6, Module.file_stream will emit
# PendingDeprecationWarning in 1.4, DeprecationWarning
# in 1.5 and finally it will be removed in 1.6, leaving
# only Module.stream as the recommended way to retrieve
# its file stream.
with warnings.catch_warnings(record=True) as cm:
warnings.simplefilter("always")
self.assertIsNot(astroid.file_stream, astroid.file_stream)
self.assertGreater(len(cm), 1)
self.assertEqual(cm[0].category, PendingDeprecationWarning)
def test_transforms_are_called_for_builtin_modules(self):
# Test that transforms are called for builtin modules.
def transform_function(node):
name = nodes.AssignName()
name.name = "value"
node.args.args = [name]
return node
manager = builder.MANAGER
predicate = lambda node: node.root().name == "time"
with add_transform(manager, nodes.FunctionDef, transform_function,
predicate):
builder_instance = builder.AstroidBuilder()
module = builder_instance.module_build(time)
asctime = module["asctime"]
self.assertEqual(len(asctime.args.args), 1)
self.assertIsInstance(asctime.args.args[0], nodes.AssignName)
self.assertEqual(asctime.args.args[0].name, "value")
def test_try_except_lineno(self):
astroid = builder.AstroidBuilder().string_build('''
try:
print (a)
except:
pass
else:
print ("bouh")
''', __name__, __file__)
try_ = astroid.body[0]
self.assertEqual(try_.fromlineno, 2)
self.assertEqual(try_.tolineno, 7)
self.assertEqual(try_.blockstart_tolineno, 2)
self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX
self.assertEqual(try_.orelse[0].tolineno, 7)
hdlr = try_.handlers[0]
self.assertEqual(hdlr.fromlineno, 4)
self.assertEqual(hdlr.tolineno, 5)
self.assertEqual(hdlr.blockstart_tolineno, 4)
def build_file(path, modname=None):
return builder.AstroidBuilder().file_build(find(path), modname)
def setUp(self):
self.builder = builder.AstroidBuilder()
class FromToLineNoTC(TestCase):
astroid = builder.AstroidBuilder().file_build(join(DATA, 'format.py'))
def test_callfunc_lineno(self):
stmts = self.astroid.body
# on line 4:
# function('aeozrijz\
# earzer', hop)
discard = stmts[0]
self.assertIsInstance(discard, nodes.Discard)
self.assertEqual(discard.fromlineno, 4)
self.assertEqual(discard.tolineno, 5)
callfunc = discard.value
self.assertIsInstance(callfunc, nodes.CallFunc)
self.assertEqual(callfunc.fromlineno, 4)
self.assertEqual(callfunc.tolineno, 5)
name = callfunc.func
self.assertIsInstance(name, nodes.Name)
self.assertEqual(name.fromlineno, 4)
self.assertEqual(name.tolineno, 4)
strarg = callfunc.args[0]
self.assertIsInstance(strarg, nodes.Const)
if hasattr(sys, 'pypy_version_info'):
lineno = 4
else:
lineno = 5 # no way for this one in CPython (is 4 actually)
self.assertEqual(strarg.fromlineno, lineno)
self.assertEqual(strarg.tolineno, lineno)
namearg = callfunc.args[1]
self.assertIsInstance(namearg, nodes.Name)
self.assertEqual(namearg.fromlineno, 5)
self.assertEqual(namearg.tolineno, 5)
# on line 10:
# fonction(1,
# 2,
# 3,
# 4)
discard = stmts[2]
self.assertIsInstance(discard, nodes.Discard)
self.assertEqual(discard.fromlineno, 10)
self.assertEqual(discard.tolineno, 13)
callfunc = discard.value
self.assertIsInstance(callfunc, nodes.CallFunc)
self.assertEqual(callfunc.fromlineno, 10)
self.assertEqual(callfunc.tolineno, 13)
name = callfunc.func
self.assertIsInstance(name, nodes.Name)
self.assertEqual(name.fromlineno, 10)
self.assertEqual(name.tolineno, 10)
for i, arg in enumerate(callfunc.args):
self.assertIsInstance(arg, nodes.Const)
self.assertEqual(arg.fromlineno, 10 + i)
self.assertEqual(arg.tolineno, 10 + i)
def test_function_lineno(self):
stmts = self.astroid.body
# on line 15:
# def definition(a,
# b,
# c):
# return a + b + c
function = stmts[3]
self.assertIsInstance(function, nodes.Function)
self.assertEqual(function.fromlineno, 15)
self.assertEqual(function.tolineno, 18)
return_ = function.body[0]
self.assertIsInstance(return_, nodes.Return)
self.assertEqual(return_.fromlineno, 18)
self.assertEqual(return_.tolineno, 18)
if sys.version_info < (3, 0):
self.assertEqual(function.blockstart_tolineno, 17)
else:
self.skipTest('FIXME http://bugs.python.org/issue10445 '
'(no line number on function args)')
def test_decorated_function_lineno(self):
astroid = builder.AstroidBuilder().string_build(
'''
@decorator
def function(
arg):
print (arg)
''', __name__, __file__)
function = astroid['function']
self.assertEqual(
function.fromlineno, 3
) # XXX discussable, but that's what is expected by pylint right now
self.assertEqual(function.tolineno, 5)
self.assertEqual(function.decorators.fromlineno, 2)
self.assertEqual(function.decorators.tolineno, 2)
if sys.version_info < (3, 0):
self.assertEqual(function.blockstart_tolineno, 4)
else:
self.skipTest('FIXME http://bugs.python.org/issue10445 '
'(no line number on function args)')
def test_class_lineno(self):
stmts = self.astroid.body
# on line 20:
# class debile(dict,
# object):
# pass
class_ = stmts[4]
self.assertIsInstance(class_, nodes.Class)
self.assertEqual(class_.fromlineno, 20)
self.assertEqual(class_.tolineno, 22)
self.assertEqual(class_.blockstart_tolineno, 21)
pass_ = class_.body[0]
self.assertIsInstance(pass_, nodes.Pass)
self.assertEqual(pass_.fromlineno, 22)
self.assertEqual(pass_.tolineno, 22)
def test_if_lineno(self):
stmts = self.astroid.body
# on line 20:
# if aaaa: pass
# else:
# aaaa,bbbb = 1,2
# aaaa,bbbb = bbbb,aaaa
if_ = stmts[5]
self.assertIsInstance(if_, nodes.If)
self.assertEqual(if_.fromlineno, 24)
self.assertEqual(if_.tolineno, 27)
self.assertEqual(if_.blockstart_tolineno, 24)
self.assertEqual(if_.orelse[0].fromlineno, 26)
self.assertEqual(if_.orelse[1].tolineno, 27)
def test_for_while_lineno(self):
for code in (
'''
for a in range(4):
print (a)
break
else:
print ("bouh")
''',
'''
while a:
print (a)
break
else:
print ("bouh")
''',
):
astroid = builder.AstroidBuilder().string_build(
code, __name__, __file__)
stmt = astroid.body[0]
self.assertEqual(stmt.fromlineno, 2)
self.assertEqual(stmt.tolineno, 6)
self.assertEqual(stmt.blockstart_tolineno, 2)
self.assertEqual(stmt.orelse[0].fromlineno, 6) # XXX
self.assertEqual(stmt.orelse[0].tolineno, 6)
def test_try_except_lineno(self):
astroid = builder.AstroidBuilder().string_build(
'''
try:
print (a)
except:
pass
else:
print ("bouh")
''', __name__, __file__)
try_ = astroid.body[0]
self.assertEqual(try_.fromlineno, 2)
self.assertEqual(try_.tolineno, 7)
self.assertEqual(try_.blockstart_tolineno, 2)
self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX
self.assertEqual(try_.orelse[0].tolineno, 7)
hdlr = try_.handlers[0]
self.assertEqual(hdlr.fromlineno, 4)
self.assertEqual(hdlr.tolineno, 5)
self.assertEqual(hdlr.blockstart_tolineno, 4)
def test_try_finally_lineno(self):
astroid = builder.AstroidBuilder().string_build(
'''
try:
print (a)
finally:
print ("bouh")
''', __name__, __file__)
try_ = astroid.body[0]
self.assertEqual(try_.fromlineno, 2)
self.assertEqual(try_.tolineno, 5)
self.assertEqual(try_.blockstart_tolineno, 2)
self.assertEqual(try_.finalbody[0].fromlineno, 5) # XXX
self.assertEqual(try_.finalbody[0].tolineno, 5)
def test_try_finally_25_lineno(self):
astroid = builder.AstroidBuilder().string_build(
'''
try:
print (a)
except:
pass
finally:
print ("bouh")
''', __name__, __file__)
try_ = astroid.body[0]
self.assertEqual(try_.fromlineno, 2)
self.assertEqual(try_.tolineno, 7)
self.assertEqual(try_.blockstart_tolineno, 2)
self.assertEqual(try_.finalbody[0].fromlineno, 7) # XXX
self.assertEqual(try_.finalbody[0].tolineno, 7)
def test_with_lineno(self):
astroid = builder.AstroidBuilder().string_build(
'''
from __future__ import with_statement
with file("/tmp/pouet") as f:
print (f)
''', __name__, __file__)
with_ = astroid.body[1]
self.assertEqual(with_.fromlineno, 3)
self.assertEqual(with_.tolineno, 4)
self.assertEqual(with_.blockstart_tolineno, 3)
def test_file_stream_physical(self):
path = resources.find('data/all.py')
astroid = builder.AstroidBuilder().file_build(path, 'all')
with open(path, 'rb') as file_io:
with warnings.catch_warnings(record=True):
self.assertEqual(astroid.file_stream.read(), file_io.read())
def setUp(self):
super(ModuleBuildTest, self).setUp()
abuilder = builder.AstroidBuilder()
import data.module
self.module = abuilder.module_build(data.module, 'data.module')
def setUp(self):
abuilder = builder.AstroidBuilder()
self.module = abuilder.module_build(test_module)
class FileBuildTC(TestCase):
module = builder.AstroidBuilder().file_build(join(DATA, 'module.py'),
'data.module')
def test_module_base_props(self):
"""test base properties and method of a astroid module"""
module = self.module
self.assertEqual(module.name, 'data.module')
self.assertEqual(module.doc, "test module for astroid\n")
self.assertEqual(module.fromlineno, 0)
self.assertIsNone(module.parent)
self.assertEqual(module.frame(), module)
self.assertEqual(module.root(), module)
self.assertEqual(module.file,
join(abspath(data.__path__[0]), 'module.py'))
self.assertEqual(module.pure_python, 1)
self.assertEqual(module.package, 0)
self.assertFalse(module.is_statement)
self.assertEqual(module.statement(), module)
self.assertEqual(module.statement(), module)
def test_module_locals(self):
"""test the 'locals' dictionary of a astroid module"""
module = self.module
_locals = module.locals
self.assertIs(_locals, module.globals)
keys = sorted(_locals.keys())
should = [
'MY_DICT', 'YO', 'YOUPI', '__revision__', 'global_access',
'modutils', 'four_args', 'os', 'redirect', 'spawn',
'LocalsVisitor', 'ASTWalker'
]
should.sort()
self.assertEqual(keys, should)
def test_function_base_props(self):
"""test base properties and method of a astroid function"""
module = self.module
function = module['global_access']
self.assertEqual(function.name, 'global_access')
self.assertEqual(function.doc, 'function test')
self.assertEqual(function.fromlineno, 11)
self.assertTrue(function.parent)
self.assertEqual(function.frame(), function)
self.assertEqual(function.parent.frame(), module)
self.assertEqual(function.root(), module)
self.assertEqual([n.name for n in function.args.args], ['key', 'val'])
self.assertEqual(function.type, 'function')
def test_function_locals(self):
"""test the 'locals' dictionary of a astroid function"""
_locals = self.module['global_access'].locals
self.assertEqual(len(_locals), 4)
keys = sorted(_locals.keys())
self.assertEqual(keys, ['i', 'key', 'local', 'val'])
def test_class_base_props(self):
"""test base properties and method of a astroid class"""
module = self.module
klass = module['YO']
self.assertEqual(klass.name, 'YO')
self.assertEqual(klass.doc, 'hehe')
self.assertEqual(klass.fromlineno, 25)
self.assertTrue(klass.parent)
self.assertEqual(klass.frame(), klass)
self.assertEqual(klass.parent.frame(), module)
self.assertEqual(klass.root(), module)
self.assertEqual(klass.basenames, [])
if PY3K:
self.assertTrue(klass.newstyle)
else:
self.assertFalse(klass.newstyle)
def test_class_locals(self):
"""test the 'locals' dictionary of a astroid class"""
module = self.module
klass1 = module['YO']
locals1 = klass1.locals
keys = sorted(locals1.keys())
self.assertEqual(keys, ['__init__', 'a'])
klass2 = module['YOUPI']
locals2 = klass2.locals
keys = locals2.keys()
keys.sort()
self.assertEqual(keys, [
'__init__', 'class_attr', 'class_method', 'method', 'static_method'
])
def test_class_instance_attrs(self):
module = self.module
klass1 = module['YO']
klass2 = module['YOUPI']
self.assertEqual(klass1.instance_attrs.keys(), ['yo'])
self.assertEqual(klass2.instance_attrs.keys(), ['member'])
def test_class_basenames(self):
module = self.module
klass1 = module['YO']
klass2 = module['YOUPI']
self.assertEqual(klass1.basenames, [])
self.assertEqual(klass2.basenames, ['YO'])
def test_method_base_props(self):
"""test base properties and method of a astroid method"""
klass2 = self.module['YOUPI']
# "normal" method
method = klass2['method']
self.assertEqual(method.name, 'method')
self.assertEqual([n.name for n in method.args.args], ['self'])
self.assertEqual(method.doc, 'method test')
self.assertEqual(method.fromlineno, 47)
self.assertEqual(method.type, 'method')
# class method
method = klass2['class_method']
self.assertEqual([n.name for n in method.args.args], ['cls'])
self.assertEqual(method.type, 'classmethod')
# static method
method = klass2['static_method']
self.assertEqual(method.args.args, [])
self.assertEqual(method.type, 'staticmethod')
def test_method_locals(self):
"""test the 'locals' dictionary of a astroid method"""
method = self.module['YOUPI']['method']
_locals = method.locals
keys = sorted(_locals)
if sys.version_info < (3, 0):
self.assertEqual(len(_locals), 5)
self.assertEqual(keys, ['a', 'autre', 'b', 'local', 'self'])
else: # ListComp variables are no more accessible outside
self.assertEqual(len(_locals), 3)
self.assertEqual(keys, ['autre', 'local', 'self'])
def build_file(path: str, modname: str | None = None) -> Module:
return builder.AstroidBuilder().file_build(find(path), modname)
import six
import astroid
from astroid import bases
from astroid import builder
from astroid import context as contextmod
from astroid import exceptions
from astroid import node_classes
from astroid import nodes
from astroid import parse
from astroid import util
from astroid import test_utils
from astroid import transforms
from . import resources
abuilder = builder.AstroidBuilder()
BUILTINS = six.moves.builtins.__name__
PY38 = sys.version_info[:2] >= (3, 8)
try:
import typed_ast # pylint: disable=unused-import
HAS_TYPED_AST = True
except ImportError:
# typed_ast merged in `ast` in Python 3.8
HAS_TYPED_AST = PY38
class AsStringTest(resources.SysPathSetup, unittest.TestCase):
def test_tuple_as_string(self):
def build(string):
return abuilder.string_build(string).body[0].value
def setUp(self) -> None:
self.manager = test_utils.brainless_manager()
self.builder = builder.AstroidBuilder(self.manager)
def test_module_build_dunder_file():
"""Test that module_build() can work with modules that have the *__file__* attribute"""
module = builder.AstroidBuilder().module_build(collections)
assert module.path[0] == collections.__file__
def get_patched_checker(name=DEFAULT_LINTER):
def get_show_msg(err_code, msg, line, col):
return "{}: [{},{}] {}".format(
"ERROR" if err_code.startswith("E9") else "WARNING", line, col,
msg)
def read_file_line(fd):
try:
(coding, lines) = tokenize.detect_encoding(fd.readline)
textfd = io.TextIOWrapper(fd, coding, line_buffering=True)
return [l.decode(coding) for l in lines] + textfd.readlines()
except (LookupError, SyntaxError, UnicodeError):
return fd.readlines()
if name == "flake8":
from flake8.api.legacy import get_style_guide
from flake8.checker import FileChecker, processor
class PatchedFileChecker(FileChecker):
def __init__(self, filename, checks, options, file_lines=None):
self.file_lines = file_lines
super().__init__(filename, checks, options)
def _make_processor(self):
return processor.FileProcessor(self.filename,
self.options,
lines=self.file_lines)
sg = get_style_guide()
def check_and_get_results(filename, file_content=None):
file_content = bytes(file_content) if file_content else b""
py_file = io.BytesIO(file_content)
flake8_mngr = sg._file_checker_manager
flake8_mngr.options.max_line_length = DEFAULT_LINE_WIDTH
checks = flake8_mngr.checks.to_dictionary()
file_chk = PatchedFileChecker(
filename,
checks,
flake8_mngr.options,
file_lines=read_file_line(py_file))
file_chk.run_checks()
g = sg._application.guide
for result in file_chk.results:
err_code, line, col, msg, code_str = result
if g.handle_error(
code=err_code,
filename=filename,
line_number=line,
column_number=col,
text=msg,
physical_line=code_str,
):
msg = get_show_msg(err_code, msg, line, col)
yield (line, msg)
return iter(())
return check_and_get_results
elif name == "pycodestyle":
from pycodestyle import Checker
def check_and_get_results(filename, file_content=None):
file_content = bytes(file_content) if file_content else b""
py_file = io.BytesIO(file_content)
chk = Checker(filename, lines=read_file_line(py_file))
chk.max_line_length = DEFAULT_LINE_WIDTH
results = chk.check_all()
results = chk.report._deferred_print
if not results:
return iter(())
for result in chk.report._deferred_print:
line, col, err_code, msg, smry = result
msg = get_show_msg(err_code, msg, line, col)
yield (line, msg)
return check_and_get_results
elif name == "pyflakes":
from pyflakes.api import check
from pyflakes.reporter import Reporter
class PyFlakeReporter(Reporter):
def __init__(self):
self.errors = []
def unexpectedError(self, filename, msg):
self.errors.append(("E9", 1, 1, msg))
def syntaxError(self, filename, msg, lineno, offset, text):
self.errors.append(("E9", lineno, offset, msg))
def flake(self, message):
self.errors.append(
("", message.lineno, message.col,
message.message % message.message_args))
def check_and_get_results(filename, file_content=None):
rprter = PyFlakeReporter()
chk = check(file_content, filename, reporter=rprter)
if not chk:
return iter(())
for result in rprter.errors:
err_code, line, col, msg = result
msg = get_show_msg(err_code, msg, line, col)
yield (line, msg)
return check_and_get_results
elif name == "pylint":
from pylint.lint import PyLinter
from pylint import utils
from pylint import interfaces
from astroid import MANAGER, builder
from pylint import reporters
bd = builder.AstroidBuilder(MANAGER)
class PatchedPyLinter(PyLinter):
def check(self, filename, file_content):
# initialize msgs_state now that all messages have been registered into
# the store
for msg in self.msgs_store.messages:
if not msg.may_be_emitted():
self._msgs_state[msg.msgid] = False
basename = (os.path.splitext(os.path.basename(filename))[0]
if filename else "untitled")
walker = utils.PyLintASTWalker(self)
self.config.reports = True
_checkers = self.prepare_checkers()
tokencheckers = [
c for c in _checkers
if interfaces.implements(c, interfaces.ITokenChecker)
and c is not self
]
rawcheckers = [
c for c in _checkers
if interfaces.implements(c, interfaces.IRawChecker)
]
# notify global begin
for checker in _checkers:
checker.open()
if interfaces.implements(checker,
interfaces.IAstroidChecker):
walker.add_checker(checker)
self.set_current_module(basename, filename)
ast_node = bd.string_build(file_content, filename,
basename)
self.file_state = utils.FileState(basename)
self._ignore_file = False
# fix the current file (if the source file was not available or
# if it's actually a c extension)
self.current_file = ast_node.file # pylint: disable=maybe-no-member
self.check_astroid_module(ast_node, walker, rawcheckers,
tokencheckers)
# warn about spurious inline messages handling
spurious_messages = self.file_state.iter_spurious_suppression_messages(
self.msgs_store)
for msgid, line, args in spurious_messages:
self.add_message(msgid, line, None, args)
# notify global end
self.stats["statement"] = walker.nbstatements
for checker in reversed(_checkers):
checker.close()
def check_and_get_results(filename, file_content=None):
if not isinstance(file_content, str):
file_content = file_content.decode(
"utf8") if file_content else ""
if not filename:
filename = ""
linter = PatchedPyLinter()
linter.load_default_plugins()
rp = reporters.json.JSONReporter()
linter.set_reporter(rp)
linter.check(filename, file_content)
for msg in rp.messages:
yield msg[
"line"], "{type}: [{line},{column}] ({message-id}) {message}".format(
**msg)
return check_and_get_results
