bee_python 0.0.3 → 0.0.4

data/tools/pylint2/pylint/lint.py

@@ -1,914 +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.
-""" %prog [options] module_or_package
-
-  Check that a module satisfy a coding standard (and more !).
-
-    %prog --help
-
-  Display this help message and exit.
-
-    %prog --help-msg <msg-id>[,<msg-id>]
-
-  Display help messages about given message identifiers and exit.
-"""
-
-# import this first to avoid builtin namespace pollution
-from pylint.checkers import utils
-
-import sys
-import os
-import re
-import tokenize
-from warnings import warn
-
-from logilab.common.configuration import UnsupportedAction, OptionsManagerMixIn
-from logilab.common.optik_ext import check_csv
-from logilab.common.modutils import load_module_from_name
-from logilab.common.interface import implements
-from logilab.common.textutils import splitstrip
-from logilab.common.fileutils import norm_open
-from logilab.common.ureports import Table, Text, Section
-from logilab.common.graph import ordered_nodes
-from logilab.common.__pkginfo__ import version as common_version
-
-from logilab.astng import MANAGER, nodes
-from logilab.astng.__pkginfo__ import version as astng_version
-
-from pylint.utils import PyLintASTWalker, UnknownMessage, MessagesHandlerMixIn,\
-     ReportsHandlerMixIn, MSG_TYPES, expand_modules
-from pylint.interfaces import ILinter, IRawChecker, IASTNGChecker
-from pylint.checkers import BaseRawChecker, EmptyReport, \
-     table_lines_from_stats
-from pylint.reporters.text import TextReporter, ParseableTextReporter, \
-     VSTextReporter, ColorizedTextReporter
-from pylint.reporters.html import HTMLReporter
-from pylint import config
-
-from pylint.__pkginfo__ import version
-
-
-OPTION_RGX = re.compile('\s*#*\s*pylint:(.*)')
-REPORTER_OPT_MAP = {'text': TextReporter,
-                    'parseable': ParseableTextReporter,
-                    'msvs': VSTextReporter,
-                    'colorized': ColorizedTextReporter,
-                    'html': HTMLReporter,}
-
-
-# Python Linter class #########################################################
-
-MSGS = {
-    'F0001': ('%s',
-              'Used when an error occurred preventing the analysis of a \
-              module (unable to find it for instance).'),
-    'F0002': ('%s: %s',
-              'Used when an unexpected error occurred while building the ASTNG \
-              representation. This is usually accompanied by a traceback. \
-              Please report such errors !'),
-    'F0003': ('ignored builtin module %s',
-              'Used to indicate that the user asked to analyze a builtin module\
-              which has been skipped.'),
-    'F0004': ('unexpected inferred value %s',
-              'Used to indicate that some value of an unexpected type has been \
-              inferred.'),
-
-    'I0001': ('Unable to run raw checkers on built-in module %s',
-              'Used to inform that a built-in module has not been checked \
-              using the raw checkers.'),
-
-    'I0010': ('Unable to consider inline option %r',
-              'Used when an inline option is either badly formatted or can\'t \
-              be used inside modules.'),
-
-    'I0011': ('Locally disabling %s',
-              'Used when an inline option disables a message or a messages \
-              category.'),
-    'I0012': ('Locally enabling %s',
-              'Used when an inline option enables a message or a messages \
-              category.'),
-    'I0013': ('Ignoring entire file',
-              'Used to inform that the file will not be checked'),
-
-
-    'E0001': ('%s',
-              'Used when a syntax error is raised for a module.'),
-
-    'E0011': ('Unrecognized file option %r',
-              'Used when an unknown inline option is encountered.'),
-    'E0012': ('Bad option value %r',
-              'Used when a bad value for an inline option is encountered.'),
-    }
-
-
-class PyLinter(OptionsManagerMixIn, MessagesHandlerMixIn, ReportsHandlerMixIn,
-               BaseRawChecker):
-    """lint Python modules using external checkers.
-
-    This is the main checker controlling the other ones and the reports
-    generation. It is itself both a raw checker and an astng checker in order
-    to:
-    * handle message activation / deactivation at the module level
-    * handle some basic but necessary stats'data (number of classes, methods...)
-    """
-
-    __implements__ = (ILinter, IRawChecker)
-
-    name = 'master'
-    priority = 0
-    level = 0
-    msgs = MSGS
-    may_be_disabled = False
-
-    options = (('ignore',
-                {'type' : 'csv', 'metavar' : '<file>',
-                 'dest' : 'black_list', 'default' : ('CVS',),
-                 'help' : 'Add <file or directory> to the black list. It \
-should be a base name, not a path. You may set this option multiple times.'}),
-
-               ('persistent',
-                {'default': True, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'level': 1,
-                 'help' : 'Pickle collected data for later comparisons.'}),
-
-               ('load-plugins',
-                {'type' : 'csv', 'metavar' : '<modules>', 'default' : (),
-                 'level': 1,
-                 'help' : 'List of plugins (as comma separated values of \
-python modules names) to load, usually to register additional checkers.'}),
-
-               ('output-format',
-                {'default': 'text', 'type': 'choice', 'metavar' : '<format>',
-                 'choices': ('text', 'parseable', 'msvs', 'colorized', 'html'),
-                 'short': 'f',
-                 'group': 'Reports',
-                 'help' : 'Set the output format. Available formats are text,\
-                 parseable, colorized, msvs (visual studio) and html'}),
-
-               ('include-ids',
-                {'type' : 'yn', 'metavar' : '<y_or_n>', 'default' : 0,
-                 'short': 'i',
-                 'group': 'Reports',
-                 'help' : 'Include message\'s id in output'}),
-
-               ('files-output',
-                {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'group': 'Reports', 'level': 1,
-                 'help' : 'Put messages in a separate file for each module / \
-package specified on the command line instead of printing them on stdout. \
-Reports (if any) will be written in a file name "pylint_global.[txt|html]".'}),
-
-               ('reports',
-                {'default': 1, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'short': 'r',
-                 'group': 'Reports',
-                 'help' : 'Tells whether to display a full report or only the\
- messages'}),
-
-               ('evaluation',
-                {'type' : 'string', 'metavar' : '<python_expression>',
-                 'group': 'Reports', 'level': 1,
-                 'default': '10.0 - ((float(5 * error + warning + refactor + \
-convention) / statement) * 10)',
-                 'help' : 'Python expression which should return a note less \
-than 10 (10 is the highest note). You have access to the variables errors \
-warning, statement which respectively contain the number of errors / warnings\
- messages and the total number of statements analyzed. This is used by the \
- global evaluation report (R0004).'}),
-
-               ('comment',
-                {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                 'group': 'Reports', 'level': 1,
-                 'help' : 'Add a comment according to your evaluation note. \
-This is used by the global evaluation report (R0004).'}),
-
-               ('enable',
-                {'type' : 'csv', 'metavar': '<msg ids>',
-                 'short': 'e',
-                 'group': 'Messages control',
-                 'help' : 'Enable the message, report, category or checker with the '
-                 'given id(s). You can either give multiple identifier '
-                 'separated by comma (,) or put this option multiple time.'}),
-
-               ('disable',
-                {'type' : 'csv', 'metavar': '<msg ids>',
-                 'short': 'd',
-                 'group': 'Messages control',
-                 'help' : 'Disable the message, report, category or checker with the '
-                 'given id(s). You can either give multiple identifier '
-                 'separated by comma (,) or put this option multiple time.'}),
-               )
-
-    option_groups = (
-        ('Messages control', 'Options controling analysis messages'),
-        ('Reports', 'Options related to output formating and reporting'),
-        )
-
-    def __init__(self, options=(), reporter=None, option_groups=(),
-                 pylintrc=None):
-        # some stuff has to be done before ancestors initialization...
-        #
-        # checkers / reporter / astng manager
-        self.reporter = None
-        self._checkers = {}
-        self._ignore_file = False
-        # visit variables
-        self.base_name = None
-        self.base_file = None
-        self.current_name = None
-        self.current_file = None
-        self.stats = None
-        # init options
-        self.options = options + PyLinter.options
-        self.option_groups = option_groups + PyLinter.option_groups
-        self._options_methods = {
-            'enable': self.enable,
-            'disable': self.disable}
-        self._bw_options_methods = {'disable-msg': self.disable,
-                                    'enable-msg': self.enable}
-        full_version = '%%prog %s, \nastng %s, common %s\nPython %s' % (
-            version, astng_version, common_version, sys.version)
-        OptionsManagerMixIn.__init__(self, usage=__doc__,
-                                     version=full_version,
-                                     config_file=pylintrc or config.PYLINTRC)
-        MessagesHandlerMixIn.__init__(self)
-        ReportsHandlerMixIn.__init__(self)
-        BaseRawChecker.__init__(self)
-        # provided reports
-        self.reports = (('RP0001', 'Messages by category',
-                         report_total_messages_stats),
-                        ('RP0002', '% errors / warnings by module',
-                         report_messages_by_module_stats),
-                        ('RP0003', 'Messages',
-                         report_messages_stats),
-                        ('RP0004', 'Global evaluation',
-                         self.report_evaluation),
-                        )
-        self.register_checker(self)
-        self._dynamic_plugins = []
-        self.load_provider_defaults()
-        self.set_reporter(reporter or TextReporter(sys.stdout))
-
-    def load_plugin_modules(self, modnames):
-        """take a list of module names which are pylint plugins and load
-        and register them
-        """
-        for modname in modnames:
-            if modname in self._dynamic_plugins:
-                continue
-            self._dynamic_plugins.append(modname)
-            module = load_module_from_name(modname)
-            module.register(self)
-
-    def set_reporter(self, reporter):
-        """set the reporter used to display messages and reports"""
-        self.reporter = reporter
-        reporter.linter = self
-
-    def set_option(self, optname, value, action=None, optdict=None):
-        """overridden from configuration.OptionsProviderMixin to handle some
-        special options
-        """
-        if optname in self._options_methods or optname in self._bw_options_methods:
-            if value:
-                try:
-                    meth = self._options_methods[optname]
-                except KeyError:
-                    meth = self._bw_options_methods[optname]
-                    warn('%s is deprecated, replace it by %s' % (
-                        optname, optname.split('-')[0]), DeprecationWarning)
-                value = check_csv(None, optname, value)
-                if isinstance(value, (list, tuple)):
-                    for _id in value :
-                        meth(_id)
-                else :
-                    meth(value)
-        elif optname == 'output-format':
-            self.set_reporter(REPORTER_OPT_MAP[value.lower()]())
-        try:
-            BaseRawChecker.set_option(self, optname, value, action, optdict)
-        except UnsupportedAction:
-            print >> sys.stderr, 'option %s can\'t be read from config file' % \
-                  optname
-
-    # checkers manipulation methods ############################################
-
-    def register_checker(self, checker):
-        """register a new checker
-
-        checker is an object implementing IRawChecker or / and IASTNGChecker
-        """
-        assert checker.priority <= 0, 'checker priority can\'t be >= 0'
-        self._checkers.setdefault(checker.name, []).append(checker)
-        if hasattr(checker, 'reports'):
-            for r_id, r_title, r_cb in checker.reports:
-                self.register_report(r_id, r_title, r_cb, checker)
-        self.register_options_provider(checker)
-        if hasattr(checker, 'msgs'):
-            self.register_messages(checker)
-        checker.load_defaults()
-
-    def disable_noerror_messages(self):
-        for msgcat, msgids in self._msgs_by_category.iteritems():
-            if msgcat == 'E':
-                for msgid in msgids:
-                    self.enable(msgid)
-            else:
-                for msgid in msgids:
-                    self.disable(msgid)
-
-    # block level option handling #############################################
-    #
-    # see func_block_disable_msg.py test case for expected behaviour
-
-    def process_tokens(self, tokens):
-        """process tokens from the current module to search for module/block
-        level options
-        """
-        comment = tokenize.COMMENT
-        newline = tokenize.NEWLINE
-        for (tok_type, _, start, _, line) in tokens:
-            if tok_type not in (comment, newline):
-                continue
-            match = OPTION_RGX.search(line)
-            if match is None:
-                continue
-            if match.group(1).strip() == "disable-all":
-                self.add_message('I0013', line=start[0])
-                self._ignore_file = True
-                return
-            try:
-                opt, value = match.group(1).split('=', 1)
-            except ValueError:
-                self.add_message('I0010', args=match.group(1).strip(),
-                                 line=start[0])
-                continue
-            opt = opt.strip()
-            if opt in self._options_methods or opt in self._bw_options_methods:
-                try:
-                    meth = self._options_methods[opt]
-                except KeyError:
-                    meth = self._bw_options_methods[opt]
-                    warn('%s is deprecated, replace it by %s (%s)' % (
-                        opt, opt.split('-')[0], self.current_file),
-                         DeprecationWarning)
-                for msgid in splitstrip(value):
-                    try:
-                        meth(msgid, 'module', start[0])
-                    except UnknownMessage:
-                        self.add_message('E0012', args=msgid, line=start[0])
-            else:
-                self.add_message('E0011', args=opt, line=start[0])
-
-    def collect_block_lines(self, node, msg_state):
-        """walk ast to collect block level options line numbers"""
-        # recurse on children (depth first)
-        for child in node.get_children():
-            self.collect_block_lines(child, msg_state)
-        first = node.fromlineno
-        last = node.tolineno
-        # first child line number used to distinguish between disable
-        # which are the first child of scoped node with those defined later.
-        # For instance in the code below:
-        #
-        # 1.   def meth8(self):
-        # 2.        """test late disabling"""
-        # 3.        # pylint: disable=E1102
-        # 4.        print self.blip
-        # 5.        # pylint: disable=E1101
-        # 6.        print self.bla
-        #
-        # E1102 should be disabled from line 1 to 6 while E1101 from line 5 to 6
-        #
-        # this is necessary to disable locally messages applying to class /
-        # function using their fromlineno
-        if isinstance(node, (nodes.Module, nodes.Class, nodes.Function)) and node.body:
-            firstchildlineno = node.body[0].fromlineno
-        else:
-            firstchildlineno = last
-        for msgid, lines in msg_state.iteritems():
-            for lineno, state in lines.items():
-                if first <= lineno <= last:
-                    if lineno > firstchildlineno:
-                        state = True
-                    # set state for all lines for this block
-                    first, last = node.block_range(lineno)
-                    for line in xrange(first, last+1):
-                        # do not override existing entries
-                        if not line in self._module_msgs_state.get(msgid, ()):
-                            if line in lines: # state change in the same block
-                                state = lines[line]
-                            try:
-                                self._module_msgs_state[msgid][line] = state
-                            except KeyError:
-                                self._module_msgs_state[msgid] = {line: state}
-                    del lines[lineno]
-
-
-    # code checking methods ###################################################
-
-    def sort_checkers(self, checkers=None):
-        if checkers is None:
-            checkers = [checker for checkers in self._checkers.values()
-                        for checker in checkers]
-        graph = {}
-        cls_instance = {}
-        for checker in checkers:
-            graph[checker.__class__] = set(checker.needs_checkers)
-            cls_instance[checker.__class__] = checker
-        checkers = [cls_instance.get(cls) for cls in ordered_nodes(graph)]
-        checkers.remove(self)
-        checkers.insert(0, self)
-        return checkers
-
-    def _get_checkers(self):
-        # compute checkers needed according to activated messages and reports
-        neededcheckers = set()
-        for checkers in self._checkers.values():
-            for checker in checkers:
-                for msgid in checker.msgs:
-                    if self._msgs_state.get(msgid, True):
-                        neededcheckers.add(checker)
-                        break
-                else:
-                    for reportid, _, _ in checker.reports:
-                        if self.is_report_enabled(reportid):
-                            neededcheckers.add(checker)
-                            break
-        return self.sort_checkers(neededcheckers)
-
-    def check(self, files_or_modules):
-        """main checking entry: check a list of files or modules from their
-        name.
-        """
-        self.reporter.include_ids = self.config.include_ids
-        if not isinstance(files_or_modules, (list, tuple)):
-            files_or_modules = (files_or_modules,)
-        checkers = self._get_checkers()
-        rawcheckers = []
-        walker = PyLintASTWalker()
-        # notify global begin
-        for checker in checkers:
-            checker.open()
-            if implements(checker, IASTNGChecker):
-                walker.add_checker(checker)
-            if implements(checker, IRawChecker) and checker is not self: #XXX
-                rawcheckers.append(checker)
-        # build ast and check modules or packages
-        for descr in self.expand_files(files_or_modules):
-            modname, filepath = descr['name'], descr['path']
-            self.set_current_module(modname, filepath)
-            # get the module representation
-            astng = self.get_astng(filepath, modname)
-            if astng is None:
-                continue
-            self.base_name = descr['basename']
-            self.base_file = descr['basepath']
-            if self.config.files_output:
-                reportfile = 'pylint_%s.%s' % (modname, self.reporter.extension)
-                self.reporter.set_output(open(reportfile, 'w'))
-            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 = astng.file
-            self.check_astng_module(astng, walker, rawcheckers)
-        # notify global end
-        self.set_current_module('')
-        self.stats['statement'] = walker.nbstatements
-        checkers.reverse()
-        for checker in checkers:
-            checker.close()
-
-    def expand_files(self, modules):
-        """get modules and errors from a list of modules and handle errors
-        """
-        result, errors = expand_modules(modules, self.config.black_list)
-        for error in errors:
-            message = modname = error["mod"]
-            key = error["key"]
-            self.set_current_module(modname)
-            if key == "F0001":
-                message = str(error["ex"]).replace(os.getcwd() + os.sep, '')
-            self.add_message(key, args=message)
-        return result
-
-    def set_current_module(self, modname, filepath=None):
-        """set the name of the currently analyzed module and
-        init statistics for it
-        """
-        if not modname and filepath is None:
-            return
-        self.current_name = modname
-        self.current_file = filepath or modname
-        self.stats['by_module'][modname] = {}
-        self.stats['by_module'][modname]['statement'] = 0
-        for msg_cat in MSG_TYPES.values():
-            self.stats['by_module'][modname][msg_cat] = 0
-        # XXX hack, to be correct we need to keep module_msgs_state
-        # for every analyzed module (the problem stands with localized
-        # messages which are only detected in the .close step)
-        if modname:
-            self._module_msgs_state = {}
-            self._module_msg_cats_state = {}
-
-    def get_astng(self, filepath, modname):
-        """return a astng representation for a module"""
-        try:
-            return MANAGER.astng_from_file(filepath, modname)
-        except SyntaxError, ex:
-            self.add_message('E0001', line=ex.lineno, args=ex.msg)
-        except KeyboardInterrupt:
-            raise
-        except Exception, ex:
-            #if __debug__:
-            #    import traceback
-            #    traceback.print_exc()
-            self.add_message('F0002', args=(ex.__class__, ex))
-
-    def check_astng_module(self, astng, walker, rawcheckers):
-        """check a module from its astng representation, real work"""
-        # call raw checkers if possible
-        if not astng.pure_python:
-            self.add_message('I0001', args=astng.name)
-        else:
-            #assert astng.file.endswith('.py')
-            stream = norm_open(astng.file)
-            # invoke IRawChecker interface on self to fetch module/block
-            # level options
-            self.process_module(stream)
-            if self._ignore_file:
-                return False
-            # walk ast to collect line numbers
-            orig_state = self._module_msgs_state.copy()
-            self._module_msgs_state = {}
-            self.collect_block_lines(astng, orig_state)
-            for checker in rawcheckers:
-                stream.seek(0)
-                checker.process_module(stream)
-        # generate events to astng checkers
-        walker.walk(astng)
-        return True
-
-    # IASTNGChecker interface #################################################
-
-    def open(self):
-        """initialize counters"""
-        self.stats = { 'by_module' : {},
-                       'by_msg' : {},
-                       }
-        for msg_cat in MSG_TYPES.values():
-            self.stats[msg_cat] = 0
-
-    def close(self):
-        """close the whole package /module, it's time to make reports !
-
-        if persistent run, pickle results for later comparison
-        """
-        if self.base_name is not None:
-            # load old results if any
-            old_stats = config.load_results(self.base_name)
-            if self.config.reports:
-                self.make_reports(self.stats, old_stats)
-            elif self.config.output_format == 'html':
-                self.reporter.display_results(Section())
-            # save results if persistent run
-            if self.config.persistent:
-                config.save_results(self.stats, self.base_name)
-
-    # specific reports ########################################################
-
-    def report_evaluation(self, sect, stats, old_stats):
-        """make the global evaluation report"""
-        # check with at least check 1 statements (usually 0 when there is a
-        # syntax error preventing pylint from further processing)
-        if stats['statement'] == 0:
-            raise EmptyReport()
-        # get a global note for the code
-        evaluation = self.config.evaluation
-        try:
-            note = eval(evaluation, {}, self.stats)
-        except Exception, ex:
-            msg = 'An exception occurred while rating: %s' % ex
-        else:
-            stats['global_note'] = note
-            msg = 'Your code has been rated at %.2f/10' % note
-            if old_stats.has_key('global_note'):
-                msg += ' (previous run: %.2f/10)' % old_stats['global_note']
-            if self.config.comment:
-                msg = '%s\n%s' % (msg, config.get_note_message(note))
-        sect.append(Text(msg))
-
-# some reporting functions ####################################################
-
-def report_total_messages_stats(sect, stats, old_stats):
-    """make total errors / warnings report"""
-    lines = ['type', 'number', 'previous', 'difference']
-    lines += table_lines_from_stats(stats, old_stats,
-                                    ('convention', 'refactor',
-                                     'warning', 'error'))
-    sect.append(Table(children=lines, cols=4, rheaders=1))
-
-def report_messages_stats(sect, stats, _):
-    """make messages type report"""
-    if not stats['by_msg']:
-        # don't print this report when we didn't detected any errors
-        raise EmptyReport()
-    in_order = [(value, msg_id)
-                for msg_id, value in stats['by_msg'].items()
-                if not msg_id.startswith('I')]
-    in_order.sort()
-    in_order.reverse()
-    lines = ('message id', 'occurrences')
-    for value, msg_id in in_order:
-        lines += (msg_id, str(value))
-    sect.append(Table(children=lines, cols=2, rheaders=1))
-
-def report_messages_by_module_stats(sect, stats, _):
-    """make errors / warnings by modules report"""
-    if len(stats['by_module']) == 1:
-        # don't print this report when we are analysing a single module
-        raise EmptyReport()
-    by_mod = {}
-    for m_type in ('fatal', 'error', 'warning', 'refactor', 'convention'):
-        total = stats[m_type]
-        for module in stats['by_module'].keys():
-            mod_total = stats['by_module'][module][m_type]
-            if total == 0:
-                percent = 0
-            else:
-                percent = float((mod_total)*100) / total
-            by_mod.setdefault(module, {})[m_type] = percent
-    sorted_result = []
-    for module, mod_info in by_mod.items():
-        sorted_result.append((mod_info['error'],
-                              mod_info['warning'],
-                              mod_info['refactor'],
-                              mod_info['convention'],
-                              module))
-    sorted_result.sort()
-    sorted_result.reverse()
-    lines = ['module', 'error', 'warning', 'refactor', 'convention']
-    for line in sorted_result:
-        if line[0] == 0 and line[1] == 0:
-            break
-        lines.append(line[-1])
-        for val in line[:-1]:
-            lines.append('%.2f' % val)
-    if len(lines) == 5:
-        raise EmptyReport()
-    sect.append(Table(children=lines, cols=5, rheaders=1))
-
-
-# utilities ###################################################################
-
-# this may help to import modules using gettext
-
-try:
-    __builtins__._ = str
-except AttributeError:
-    __builtins__['_'] = str
-
-
-def preprocess_options(args, search_for):
-    """look for some options (keys of <search_for>) which have to be processed
-    before others
-
-    values of <search_for> are callback functions to call when the option is
-    found
-    """
-    i = 0
-    while i < len(args):
-        arg = args[i]
-        if arg.startswith('--'):
-            try:
-                option, val = arg[2:].split('=', 1)
-            except ValueError:
-                option, val = arg[2:], None
-            try:
-                cb, takearg = search_for[option]
-                del args[i]
-                if takearg and val is None:
-                    val = args[i]
-                    del args[i]
-                cb(option, val)
-            except KeyError:
-                i += 1
-        else:
-            i += 1
-
-class Run:
-    """helper class to use as main for pylint :
-
-    run(*sys.argv[1:])
-    """
-    LinterClass = PyLinter
-    option_groups = (
-        ('Commands', 'Options which are actually commands. Options in this \
-group are mutually exclusive.'),
-        )
-
-    def __init__(self, args, reporter=None, exit=True):
-        self._rcfile = None
-        self._plugins = []
-        preprocess_options(args, {
-            # option: (callback, takearg)
-            'rcfile':       (self.cb_set_rcfile, True),
-            'load-plugins': (self.cb_add_plugins, True),
-            })
-        self.linter = linter = self.LinterClass((
-            ('rcfile',
-             {'action' : 'callback', 'callback' : lambda *args: 1,
-              'type': 'string', 'metavar': '<file>',
-              'help' : 'Specify a configuration file.'}),
-
-            ('init-hook',
-             {'action' : 'callback', 'type' : 'string', 'metavar': '<code>',
-              'callback' : cb_init_hook, 'level': 1,
-              'help' : 'Python code to execute, usually for sys.path \
-manipulation such as pygtk.require().'}),
-
-            ('help-msg',
-             {'action' : 'callback', 'type' : 'string', 'metavar': '<msg-id>',
-              'callback' : self.cb_help_message,
-              'group': 'Commands',
-              'help' : '''Display a help message for the given message id and \
-exit. The value may be a comma separated list of message ids.'''}),
-
-            ('list-msgs',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_list_messages,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's messages."}),
-
-            ('full-documentation',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_full_documentation,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's full documentation."}),
-
-            ('generate-rcfile',
-             {'action' : 'callback', 'callback' : self.cb_generate_config,
-              'group': 'Commands',
-              'help' : '''Generate a sample configuration file according to \
-the current configuration. You can put other options before this one to get \
-them in the generated configuration.'''}),
-
-            ('generate-man',
-             {'action' : 'callback', 'callback' : self.cb_generate_manpage,
-              'group': 'Commands',
-              'help' : "Generate pylint's man page.",'hide': True}),
-
-            ('errors-only',
-             {'action' : 'callback', 'callback' : self.cb_error_mode,
-              'short': 'E',
-              'help' : '''In error mode, checkers without error messages are \
-disabled and for others, only the ERROR messages are displayed, and no reports \
-are done by default'''}),
-
-            ('profile',
-             {'type' : 'yn', 'metavar' : '<y_or_n>',
-              'default': False, 'hide': True,
-              'help' : 'Profiled execution.'}),
-
-            ), option_groups=self.option_groups,
-               reporter=reporter, pylintrc=self._rcfile)
-        # register standard checkers
-        from pylint import checkers
-        checkers.initialize(linter)
-        # load command line plugins
-        linter.load_plugin_modules(self._plugins)
-        # add some help section
-        linter.add_help_section('Environment variables', config.ENV_HELP, level=1)
-        linter.add_help_section('Output', '''
-Using the default text output, the message format is :                          
-                                                                                
-        MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE                                
-                                                                                
-There are 5 kind of message types :                                             
-    * (C) convention, for programming standard violation                        
-    * (R) refactor, for bad code smell                                          
-    * (W) warning, for python specific problems                                 
-    * (E) error, for probable bugs in the code                                  
-    * (F) fatal, if an error occurred which prevented pylint from doing further
-processing.
-        ''', level=1)
-        linter.add_help_section('Output status code', '''
-Pylint should leave with following status code:                                 
-    * 0 if everything went fine                                                 
-    * 1 if a fatal message was issued                                           
-    * 2 if an error message was issued                                          
-    * 4 if a warning message was issued                                         
-    * 8 if a refactor message was issued                                        
-    * 16 if a convention message was issued                                     
-    * 32 on usage error                                                         
-                                                                                
-status 1 to 16 will be bit-ORed so you can know which different categories has
-been issued by analysing pylint output status code
-        ''', level=1)
-        # read configuration
-        linter.disable('W0704')
-        linter.read_config_file()
-        # is there some additional plugins in the file configuration, in
-        config_parser = linter.cfgfile_parser
-        if config_parser.has_option('MASTER', 'load-plugins'):
-            plugins = splitstrip(config_parser.get('MASTER', 'load-plugins'))
-            linter.load_plugin_modules(plugins)
-        # now we can load file config and command line, plugins (which can
-        # provide options) have been registered
-        linter.load_config_file()
-        if reporter:
-            # if a custom reporter is provided as argument, it may be overridden
-            # by file parameters, so re-set it here, but before command line
-            # parsing so it's still overrideable by command line option
-            linter.set_reporter(reporter)
-        args = linter.load_command_line_configuration(args)
-        if not args:
-            print linter.help()
-            sys.exit(32)
-        # insert current working directory to the python path to have a correct
-        # behaviour
-        sys.path.insert(0, os.getcwd())
-        if self.linter.config.profile:
-            print >> sys.stderr, '** profiled run'
-            from hotshot import Profile, stats
-            prof = Profile('stones.prof')
-            prof.runcall(linter.check, args)
-            prof.close()
-            data = stats.load('stones.prof')
-            data.strip_dirs()
-            data.sort_stats('time', 'calls')
-            data.print_stats(30)
-        else:
-            linter.check(args)
-        sys.path.pop(0)
-        if exit:
-            sys.exit(self.linter.msg_status)
-
-    def cb_set_rcfile(self, name, value):
-        """callback for option preprocessing (i.e. before optik parsing)"""
-        self._rcfile = value
-
-    def cb_add_plugins(self, name, value):
-        """callback for option preprocessing (i.e. before optik parsing)"""
-        self._plugins.extend(splitstrip(value))
-
-    def cb_error_mode(self, *args, **kwargs):
-        """error mode:
-        * disable all but error messages
-        * disable the 'miscellaneous' checker which can be safely deactivated in
-          debug
-        * disable reports
-        * do not save execution information
-        """
-        self.linter.disable_noerror_messages()
-        self.linter.disable('miscellaneous')
-        self.linter.set_option('reports', False)
-        self.linter.set_option('persistent', False)
-
-    def cb_generate_config(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        self.linter.generate_config(skipsections=('COMMANDS',))
-        sys.exit(0)
-
-    def cb_generate_manpage(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        from pylint import __pkginfo__
-        self.linter.generate_manpage(__pkginfo__)
-        sys.exit(0)
-
-    def cb_help_message(self, option, optname, value, parser):
-        """optik callback for printing some help about a particular message"""
-        self.linter.help_message(splitstrip(value))
-        sys.exit(0)
-
-    def cb_full_documentation(self, option, optname, value, parser):
-        """optik callback for printing full documentation"""
-        self.linter.print_full_documentation()
-        sys.exit(0)
-
-    def cb_list_messages(self, option, optname, value, parser): # FIXME
-        """optik callback for printing available messages"""
-        self.linter.list_messages()
-        sys.exit(0)
-
-def cb_init_hook(option, optname, value, parser):
-    """exec arbitrary code to set sys.path for instance"""
-    exec value
-
-
-if __name__ == '__main__':
-    Run(sys.argv[1:])