bee_python 0.0.3 → 0.0.4

data/tools/pylint2/pylint/utils.py

@@ -1,518 +0,0 @@
-# Copyright (c) 2003-2010 Sylvain Thenault (thenault@gmail.com).
-# Copyright (c) 2003-2010 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.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-"""some various utilities and helper classes, most of them used in the
-main pylint class
-"""
-
-import sys
-from os import linesep
-from os.path import dirname, basename, splitext, exists, isdir, join, normpath
-
-from logilab.common.modutils import modpath_from_file, get_module_files, \
-                                    file_from_modpath
-from logilab.common.textutils import normalize_text
-from logilab.common.configuration import rest_format_section
-from logilab.common.ureports import Section
-
-from logilab.astng import nodes, Module
-
-from pylint.checkers import EmptyReport
-
-class UnknownMessage(Exception):
-    """raised when a unregistered message id is encountered"""
-
-
-MSG_TYPES = {
-    'I' : 'info',
-    'C' : 'convention',
-    'R' : 'refactor',
-    'W' : 'warning',
-    'E' : 'error',
-    'F' : 'fatal'
-    }
-MSG_TYPES_LONG = dict([(v, k) for k, v in MSG_TYPES.iteritems()])
-
-MSG_TYPES_STATUS = {
-    'I' : 0,
-    'C' : 16,
-    'R' : 8,
-    'W' : 4,
-    'E' : 2,
-    'F' : 1
-    }
-
-def sort_msgs(msgids):
-    """sort message identifiers according to their category first"""
-    msg_order = 'EWRCIF'
-    def cmp_func(msgid1, msgid2):
-        """comparison function for two message identifiers"""
-        if msgid1[0] != msgid2[0]:
-            return cmp(msg_order.index(msgid1[0]), msg_order.index(msgid2[0]))
-        else:
-            return cmp(msgid1, msgid2)
-    msgids.sort(cmp_func)
-    return msgids
-
-def get_module_and_frameid(node):
-    """return the module name and the frame id in the module"""
-    frame = node.frame()
-    module, obj = '', []
-    while frame:
-        if isinstance(frame, Module):
-            module = frame.name
-        else:
-            obj.append(getattr(frame, 'name', '<lambda>'))
-        try:
-            frame = frame.parent.frame()
-        except AttributeError:
-            frame = None
-    obj.reverse()
-    return module, '.'.join(obj)
-
-def category_id(id):
-    id = id.upper()
-    if id in MSG_TYPES:
-        return id
-    return MSG_TYPES_LONG.get(id)
-
-
-class Message:
-    def __init__(self, checker, msgid, msg, descr):
-        assert len(msgid) == 5, 'Invalid message id %s' % msgid
-        assert msgid[0] in MSG_TYPES, \
-               'Bad message type %s in %r' % (msgid[0], msgid)
-        self.msgid = msgid
-        self.msg = msg
-        self.descr = descr
-        self.checker = checker
-
-class MessagesHandlerMixIn:
-    """a mix-in class containing all the messages related methods for the main
-    lint class
-    """
-
-    def __init__(self):
-        # dictionary of registered messages
-        self._messages = {}
-        self._msgs_state = {}
-        self._module_msgs_state = {} # None
-        self._msgs_by_category = {}
-        self.msg_status = 0
-
-    def register_messages(self, checker):
-        """register a dictionary of messages
-
-        Keys are message ids, values are a 2-uple with the message type and the
-        message itself
-
-        message ids should be a string of len 4, where the to first characters
-        are the checker id and the two last the message id in this checker
-        """
-        msgs_dict = checker.msgs
-        chkid = None
-        for msgid, (msg, msgdescr) in msgs_dict.items():
-            # avoid duplicate / malformed ids
-            assert not self._messages.has_key(msgid), \
-                   'Message id %r is already defined' % msgid
-            assert chkid is None or chkid == msgid[1:3], \
-                   'Inconsistent checker part in message id %r' % msgid
-            chkid = msgid[1:3]
-            self._messages[msgid] = Message(checker, msgid, msg, msgdescr)
-            self._msgs_by_category.setdefault(msgid[0], []).append(msgid)
-
-    def get_message_help(self, msgid, checkerref=False):
-        """return the help string for the given message id"""
-        msg = self.check_message_id(msgid)
-        desc = normalize_text(' '.join(msg.descr.split()), indent='  ')
-        if checkerref:
-            desc += ' This message belongs to the %s checker.' % \
-                   msg.checker.name
-        title = msg.msg
-        if title != '%s':
-            title = title.splitlines()[0]
-            return ':%s: *%s*\n%s' % (msg.msgid, title, desc)
-        return ':%s:\n%s' % (msg.msgid, desc)
-
-    def disable(self, msgid, scope='package', line=None):
-        """don't output message of the given id"""
-        assert scope in ('package', 'module')
-        # msgid is a category?
-        catid = category_id(msgid)
-        if catid is not None:
-            for msgid in self._msgs_by_category.get(catid):
-                self.disable(msgid, scope, line)
-            return
-        # msgid is a checker name?
-        if msgid.lower() in self._checkers:
-            for checker in self._checkers[msgid.lower()]:
-                for msgid in checker.msgs:
-                    self.disable(msgid, scope, line)
-            return
-        # msgid is report id?
-        if msgid.lower().startswith('rp'):
-            self.disable_report(msgid)
-            return
-        # msgid is a msgid.
-        msg = self.check_message_id(msgid)
-        if scope == 'module':
-            assert line > 0
-            try:
-                self._module_msgs_state[msg.msgid][line] = False
-            except KeyError:
-                self._module_msgs_state[msg.msgid] = {line: False}
-                if msgid != 'I0011':
-                    self.add_message('I0011', line=line, args=msg.msgid)
-
-        else:
-            msgs = self._msgs_state
-            msgs[msg.msgid] = False
-            # sync configuration object
-            self.config.disable_msg = [mid for mid, val in msgs.items()
-                                       if not val]
-
-    def enable(self, msgid, scope='package', line=None):
-        """reenable message of the given id"""
-        assert scope in ('package', 'module')
-        catid = category_id(msgid)
-        # msgid is a category?
-        if catid is not None:
-            for msgid in self._msgs_by_category.get(catid):
-                self.enable(msgid, scope, line)
-            return
-        # msgid is a checker name?
-        if msgid.lower() in self._checkers:
-            for checker in self._checkers[msgid.lower()]:
-                for msgid in checker.msgs:
-                    self.enable(msgid, scope, line)
-            return
-        # msgid is report id?
-        if msgid.lower().startswith('rp'):
-            self.enable_report(msgid)
-            return
-        # msgid is a msgid.
-        msg = self.check_message_id(msgid)
-        if scope == 'module':
-            assert line > 0
-            try:
-                self._module_msgs_state[msg.msgid][line] = True
-            except KeyError:
-                self._module_msgs_state[msg.msgid] = {line: True}
-                self.add_message('I0012', line=line, args=msg.msgid)
-        else:
-            msgs = self._msgs_state
-            msgs[msg.msgid] = True
-            # sync configuration object
-            self.config.enable = [mid for mid, val in msgs.items() if val]
-
-    def check_message_id(self, msgid):
-        """raise UnknownMessage if the message id is not defined"""
-        msgid = msgid.upper()
-        try:
-            return self._messages[msgid]
-        except KeyError:
-            raise UnknownMessage('No such message id %s' % msgid)
-
-    def is_message_enabled(self, msgid, line=None):
-        """return true if the message associated to the given message id is
-        enabled
-        """
-        if line is None:
-            return self._msgs_state.get(msgid, True)
-        try:
-            return self._module_msgs_state[msgid][line]
-        except (KeyError, TypeError):
-            return self._msgs_state.get(msgid, True)
-
-    def add_message(self, msgid, line=None, node=None, args=None):
-        """add the message corresponding to the given id.
-
-        If provided, msg is expanded using args
-
-        astng checkers should provide the node argument, raw checkers should
-        provide the line argument.
-        """
-        if line is None and node is not None:
-            line = node.fromlineno
-        # should this message be displayed
-        if not self.is_message_enabled(msgid, line):
-            return
-        # update stats
-        msg_cat = MSG_TYPES[msgid[0]]
-        self.msg_status |= MSG_TYPES_STATUS[msgid[0]]
-        self.stats[msg_cat] += 1
-        self.stats['by_module'][self.current_name][msg_cat] += 1
-        try:
-            self.stats['by_msg'][msgid] += 1
-        except KeyError:
-            self.stats['by_msg'][msgid] = 1
-        msg = self._messages[msgid].msg
-        # expand message ?
-        if args:
-            msg %= args
-        # get module and object
-        if node is None:
-            module, obj = self.current_name, ''
-            path = self.current_file
-        else:
-            module, obj = get_module_and_frameid(node)
-            path = node.root().file
-        # add the message
-        self.reporter.add_message(msgid, (path, module, obj, line or 1), msg)
-
-    def help_message(self, msgids):
-        """display help messages for the given message identifiers"""
-        for msgid in msgids:
-            try:
-                print self.get_message_help(msgid, True)
-                print
-            except UnknownMessage, ex:
-                print ex
-                print
-                continue
-
-    def print_full_documentation(self):
-        """output a full documentation in ReST format"""
-        by_checker = {}
-        for checker in self.sort_checkers():
-            if checker.name == 'master':
-                prefix = 'Main '
-                if checker.options:
-                    for section, options in checker.options_by_section():
-                        if section is None:
-                            title = 'General options'
-                        else:
-                            title = '%s options' % section.capitalize()
-                        print title
-                        print '~' * len(title)
-                        rest_format_section(sys.stdout, None, options)
-                        print
-            else:
-                try:
-                    by_checker[checker.name][0] += checker.options_and_values()
-                    by_checker[checker.name][1].update(checker.msgs)
-                    by_checker[checker.name][2] += checker.reports
-                except KeyError:
-                    by_checker[checker.name] = [list(checker.options_and_values()),
-                                                dict(checker.msgs),
-                                                list(checker.reports)]
-        for checker, (options, msgs, reports) in by_checker.items():
-            prefix = ''
-            title = '%s checker' % checker
-            print title
-            print '-' * len(title)
-            if options:
-                title = 'Options'
-                print title
-                print '~' * len(title)
-                rest_format_section(sys.stdout, None, options)
-                print
-            if msgs:
-                title = ('%smessages' % prefix).capitalize()
-                print title
-                print '~' * len(title)
-                for msgid in sort_msgs(msgs.keys()):
-                    print self.get_message_help(msgid, False)
-                print
-            if reports:
-                title = ('%sreports' % prefix).capitalize()
-                print title
-                print '~' * len(title)
-                for report in reports:
-                    print ':%s: %s' % report[:2]
-                print
-            print
-
-    def list_messages(self):
-        """output full messages list documentation in ReST format"""
-        msgids = []
-        for checker in self.sort_checkers():
-            for msgid in checker.msgs.keys():
-                msgids.append(msgid)
-        msgids.sort()
-        for msgid in msgids:
-            print self.get_message_help(msgid, False)
-        print
-
-
-class ReportsHandlerMixIn:
-    """a mix-in class containing all the reports and stats manipulation
-    related methods for the main lint class
-    """
-    def __init__(self):
-        self._reports = {}
-        self._reports_state = {}
-
-    def register_report(self, reportid, r_title, r_cb, checker):
-        """register a report
-
-        reportid is the unique identifier for the report
-        r_title the report's title
-        r_cb the method to call to make the report
-        checker is the checker defining the report
-        """
-        reportid = reportid.upper()
-        self._reports.setdefault(checker, []).append( (reportid, r_title, r_cb) )
-
-    def enable_report(self, reportid):
-        """disable the report of the given id"""
-        reportid = reportid.upper()
-        self._reports_state[reportid] = True
-
-    def disable_report(self, reportid):
-        """disable the report of the given id"""
-        reportid = reportid.upper()
-        self._reports_state[reportid] = False
-
-    def is_report_enabled(self, reportid):
-        """return true if the report associated to the given identifier is
-        enabled
-        """
-        return self._reports_state.get(reportid, True)
-
-    def make_reports(self, stats, old_stats):
-        """render registered reports"""
-        if self.config.files_output:
-            filename = 'pylint_global.' + self.reporter.extension
-            self.reporter.set_output(open(filename, 'w'))
-        sect = Section('Report',
-                       '%s statements analysed.'% (self.stats['statement']))
-        checkers = self.sort_checkers(self._reports)
-        checkers.reverse()
-        for checker in checkers:
-            for reportid, r_title, r_cb in self._reports[checker]:
-                if not self.is_report_enabled(reportid):
-                    continue
-                report_sect = Section(r_title)
-                try:
-                    r_cb(report_sect, stats, old_stats)
-                except EmptyReport:
-                    continue
-                report_sect.report_id = reportid
-                sect.append(report_sect)
-        self.reporter.display_results(sect)
-
-    def add_stats(self, **kwargs):
-        """add some stats entries to the statistic dictionary
-        raise an AssertionError if there is a key conflict
-        """
-        for key, value in kwargs.items():
-            if key[-1] == '_':
-                key = key[:-1]
-            assert not self.stats.has_key(key)
-            self.stats[key] = value
-        return self.stats
-
-
-def expand_modules(files_or_modules, black_list):
-    """take a list of files/modules/packages and return the list of tuple
-    (file, module name) which have to be actually checked
-    """
-    result = []
-    errors = []
-    for something in files_or_modules:
-        if exists(something):
-            # this is a file or a directory
-            try:
-                modname = '.'.join(modpath_from_file(something))
-            except ImportError:
-                modname = splitext(basename(something))[0]
-            if isdir(something):
-                filepath = join(something, '__init__.py')
-            else:
-                filepath = something
-        else:
-            # suppose it's a module or package
-            modname = something
-            try:
-                filepath = file_from_modpath(modname.split('.'))
-                if filepath is None:
-                    errors.append( {'key' : 'F0003', 'mod': modname} )
-                    continue
-            except ImportError, ex:
-                errors.append( {'key': 'F0001', 'mod': modname, 'ex': ex} )
-                continue
-        filepath = normpath(filepath)
-        result.append( {'path': filepath, 'name': modname,
-                        'basepath': filepath, 'basename': modname} )
-        if not (modname.endswith('.__init__') or modname == '__init__') \
-                and '__init__.py' in filepath:
-            for subfilepath in get_module_files(dirname(filepath), black_list):
-                if filepath == subfilepath:
-                    continue
-                submodname = '.'.join(modpath_from_file(subfilepath))
-                result.append( {'path': subfilepath, 'name': submodname,
-                                'basepath': filepath, 'basename': modname} )
-    return result, errors
-
-
-class PyLintASTWalker(object):
-    def __init__(self):
-        # callbacks per node types
-        self.nbstatements = 1
-        self.visit_events = {}
-        self.leave_events = {}
-
-    def add_checker(self, checker):
-        hasvdefault = False
-        vcids = set()
-        hasldefault = False
-        lcids = set()
-        for member in dir(checker):
-            if member.startswith('visit_'):
-                cid = member[6:]
-                if cid != 'default':
-                    cbs = self.visit_events.setdefault(cid, [])
-                    cbs.append(getattr(checker, member))
-                    vcids.add(cid)
-                else:
-                    hasvdefault = getattr(checker, member)
-            elif member.startswith('leave_'):
-                cid = member[6:]
-                if cid != 'default':
-                    cbs = self.leave_events.setdefault(cid, [])
-                    cbs.append(getattr(checker, member))
-                    lcids.add(cid)
-                else:
-                    hasldefault = getattr(checker, member)
-        if hasvdefault:
-            for cls in nodes.ALL_NODE_CLASSES:
-                cid = cls.__name__.lower()
-                if cid not in vcids:
-                    cbs = self.visit_events.setdefault(cid, [])
-                    cbs.append(hasvdefault)
-        if hasldefault:
-            for cls in nodes.ALL_NODE_CLASSES:
-                cid = cls.__name__.lower()
-                if cid not in lcids:
-                    cbs = self.leave_events.setdefault(cid, [])
-                    cbs.append(hasldefault)
-
-    def walk(self, astng):
-        """call visit events of astng checkers for the given node, recurse on
-        its children, then leave events.
-        """
-        cid = astng.__class__.__name__.lower()
-        if astng.is_statement:
-            self.nbstatements += 1
-        # generate events for this node on each checker
-        for cb in self.visit_events.get(cid, ()):
-            cb(astng)
-        # recurse on children
-        for child in astng.get_children():
-            self.walk(child)
-        for cb in self.leave_events.get(cid, ()):
-            cb(astng)

data/tools/pylint2/pylint.py

@@ -1,16 +0,0 @@
-#!/usr/bin/python
-# coding: UTF-8
-
-import os
-import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'logilab'))
-from pylint import lint
-
-# add PYTHONPATH in sys.path (shoud be already done !?)
-if 'PYTHONPATH' in os.environ.keys():
-    dirs = os.environ['PYTHONPATH'].split(os.pathsep)
-    for dir in dirs:
-        sys.path.insert(0, dir)
-
-lint.Run(sys.argv[1:])
-