Disable pytest's logs reporting
CubicWeb already prints captured logs in stderr upon test failure, so we
get them twice. Until we fix our logging management, disabling pytest
capture and restore brings the output level back to sanity.
"""Pylint plugin to analyse cubicweb cubes
Done:
* turn functions decorated by @objectify_predicate into classes
* add yams base types to yams.buildobjs module
* add data() function to uiprops module's namespace
* avoid 'abstract method not implemented' for `cell_call`, `entity_call`, `render_body`
* avoid invalid-name on schema relation class names
TODO:
* avoid invalid class name for predicates and predicates
* W:188, 0: Method '__lt__' is abstract in class 'Entity' but is not overridden (abstract-method)
* generate entity attributes from the schema?
"""
from astroid import MANAGER, InferenceError, nodes, ClassDef, FunctionDef
from astroid.builder import AstroidBuilder
from pylint.checkers.utils import unimplemented_abstract_methods, class_is_abstract
def turn_function_to_class(node):
"""turn a Function node into a Class node (in-place)"""
node.__class__ = ClassDef
node.bases = ()
# mark class as a new style class
node._newstyle = True
# remove return nodes so that we don't get warned about 'return outside
# function' by pylint
for rnode in node.nodes_of_class(nodes.Return):
rnode.parent.body.remove(rnode)
# add __init__ method to avoid no-init
# that seems to be enough :)
def cubicweb_transform(module):
# handle objectify_predicate decorator (and its former name until bw compat
# is kept). Only look at module level functions, should be enough.
for assnodes in module.locals.values():
for node in assnodes:
if isinstance(node, FunctionDef) and node.decorators:
for decorator in node.decorators.nodes:
try:
for infered in decorator.infer():
if infered.name in ('objectify_predicate', 'objectify_selector'):
turn_function_to_class(node)
break
else:
continue
break
except InferenceError:
continue
# add yams base types into 'yams.buildobjs', astng doesn't grasp globals()
# magic in there
if module.name == 'yams.buildobjs':
from yams import BASE_TYPES
for etype in BASE_TYPES:
module.locals[etype] = [ClassDef(etype, None)]
# add data() to uiprops module
elif module.name.split('.')[-1] == 'uiprops':
fake = AstroidBuilder(MANAGER).string_build('''
def data(string):
return u''
''')
module.locals['data'] = fake.locals['data']
# handle lower case with underscores for relation names in schema.py
if not module.qname().endswith('.schema'):
return
schema_locals = module.locals
for assnodes in schema_locals.values():
for node in assnodes:
if not isinstance(node, ClassDef):
continue
# XXX can we infer ancestor classes? it would be better to know for sure that
# one of the mother classes is yams.buildobjs.RelationDefinition for instance
for base in node.basenames:
if base in ('RelationDefinition', 'ComputedRelation', 'RelationType'):
new_name = node.name.replace('_', '').capitalize()
schema_locals[new_name] = schema_locals[node.name]
del schema_locals[node.name]
node.name = new_name
def cubicweb_abstractmethods_transform(classdef):
if class_is_abstract(classdef):
return
def is_abstract(method):
return method.is_abstract(pass_is_abstract=False)
methods = sorted(
unimplemented_abstract_methods(classdef, is_abstract).items(),
key=lambda item: item[0],
)
dummy_method = AstroidBuilder(MANAGER).string_build('''
def dummy_method(self):
""""""
''')
for name, method in methods:
owner = method.parent.frame()
if owner is classdef:
continue
if name not in classdef.locals:
if name in ('cell_call', 'entity_call', 'render_body'):
classdef.set_local(name, dummy_method)
def register(linter):
"""called when loaded by pylint --load-plugins, nothing to do here"""
MANAGER.register_transform(nodes.Module, cubicweb_transform)
MANAGER.register_transform(ClassDef, cubicweb_abstractmethods_transform)