Example #1
0
def shell(args: List[str] = None, error: bool = True):
    """Endpoint for console.

    Parse a command arguments, configuration files and run a checkers.
    """
    if args is None:
        args = sys.argv[1:]

    options = parse_options(args)
    setup_logger(options)
    LOGGER.info(options)

    # Install VSC hook
    if options.hook:
        from .hook import install_hook  # noqa

        for path in options.paths:
            return install_hook(path)

    if options.from_stdin and not options.paths:
        LOGGER.error("--from-stdin requires a filename")
        return sys.exit(1)

    errors = check_paths(
        options.paths,
        code=read_stdin() if options.from_stdin else None,
        options=options,
        rootdir=CURDIR,
    )
    display_errors(errors, options)

    if error:
        sys.exit(int(bool(errors)))

    return errors
Example #2
0
def display_errors(errors: List[Error], options: Namespace):
    """Format and display the given errors."""
    if options.format == "json":
        LOGGER.warning(dumps([err.to_dict() for err in errors]))

    else:
        pattern = MESSAGE_FORMATS.get(options.format, DEFAULT_FORMAT)
        for err in errors:
            LOGGER.warning(err.format(pattern))
Example #3
0
    def parse_options(args=None, config=True, rootdir=pylamaconfig.CURDIR, **overrides):
        """ Parse options from command line and configuration files.
        :return argparse.Namespace:
        """
        args = args or []

        # Parse args from command string
        options = pylamaconfig.PARSER.parse_args(args)
        options.file_params = dict()
        options.linters_params = dict()

        # Compile options from ini
        if config:
            cfg = get_config(str(options.options), rootdir=rootdir)
            for opt, val in cfg.default.items():
                LOGGER.info("Find option %s (%s)", opt, val)
                passed_value = getattr(options, opt, pylamaconfig._Default())
                if isinstance(passed_value, pylamaconfig._Default):
                    if opt == "paths":
                        val = val.split()
                    elif opt == "skip":
                        val = pylamaconfig.fix_pathname_sep(val)
                    setattr(options, opt, pylamaconfig._Default(val))

            # Parse file related options
            for name, opts in cfg.sections.items():

                if name == cfg.default_section:
                    continue

                if name.startswith(cfg.default_section):
                    name = name[7:]

                if name in pylamaconfig.LINTERS:
                    options.linters_params[name] = dict(opts)
                    continue

                mask = re.compile(
                    pylamaconfig.fnmatch.translate(pylamaconfig.fix_pathname_sep(name))
                )
                options.file_params[mask] = dict(opts)

        # Override options
        pylamaconfig._override_options(options, **overrides)

        # Postprocess options
        for name in options.__dict__:
            value = getattr(options, name)
            if isinstance(value, pylamaconfig._Default):
                setattr(options, name, pylamaconfig.process_value(name, value.value))

        if options.concurrent and "pylint" in options.linters:
            LOGGER.warning("Can't parse code asynchronously with pylint enabled.")
            options.concurrent = False

        return options
Example #4
0
def code_check():
    """ Run pylama and check current file.

    :return bool:

    """

    with silence_stderr():

        from pylama.main import parse_options
        from pylama.tasks import check_path

        if not env.curbuf.name:
            return env.stop()

        options = parse_options(
            ignore=env.var('g:pymode_lint_ignore'),
            select=env.var('g:pymode_lint_select'),
            linters=env.var('g:pymode_lint_checkers'),
        )

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(
                p.match(path) for p in options.skip):  # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = check_path(path,
                            options=options,
                            code='\n'.join(env.curbuf) + '\n')

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e['bufnr'] = env.curbuf.number

    env.run('g:PymodeLocList.current().extend', errors)
Example #5
0
def code_check():
    """ Run pylama and check current file.

    :return bool:

    """

    with silence_stderr():

        from pylama.main import parse_options
        from pylama.tasks import check_path

        if not env.curbuf.name:
            return env.stop()

        options = parse_options(
            ignore=env.var('g:pymode_lint_ignore'),
            select=env.var('g:pymode_lint_select'),
            linters=env.var('g:pymode_lint_checkers'),
        )
        env.debug(options)

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(p.match(path) for p in options.skip): # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = check_path(
            path, options=options, code='\n'.join(env.curbuf) + '\n')

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e['bufnr'] = env.curbuf.number

    env.run('g:PymodeLocList.current().extend', errors)
Example #6
0
    def process_paths(options, candidates=None, error=True):
        """Process files and log errors."""
        errors = pylama.check_path(options, rootdir=pylamaconfig.CURDIR, candidates=candidates)

        pattern = "%(filename)s:%(lnum)s:%(col)s:%(type)s:%(number)s:%(text)s"

        for er in errors:
            text = er._info["text"].split()
            if PATTERN_NUMBER.match(text[0]):
                er._info["text"] = " ".join(text[1:])

            if not er._info["number"]:
                er._info["number"] = f"0000"

            if options.abspath:
                er._info["filename"] = ospath.abspath(er.filename)
            LOGGER.warning(pattern, er._info)

        if error:
            sys.exit(int(bool(errors)))

        return errors
Example #7
0
def code_check():
    """Run pylama and check current file.

    :return bool:

    """
    with silence_stderr():

        from pylama.core import run
        from pylama.config import parse_options

        if not env.curbuf.name:
            return env.stop()

        linters = env.var('g:pymode_lint_checkers')
        env.debug(linters)

        # Fixed in v0.9.3: these two parameters may be passed as strings.
        # DEPRECATE: v:0.10.0: need to be set as lists.
        if isinstance(env.var('g:pymode_lint_ignore'), str):
            raise ValueError ('g:pymode_lint_ignore should have a list type')
        else:
            ignore = env.var('g:pymode_lint_ignore')
        if isinstance(env.var('g:pymode_lint_select'), str):
            raise ValueError ('g:pymode_lint_select should have a list type')
        else:
            select = env.var('g:pymode_lint_select')
        options = parse_options(
            linters=linters, force=1,
            ignore=ignore,
            select=select,
        )
        env.debug(options)

        for linter in linters:
            opts = env.var('g:pymode_lint_options_%s' % linter, silence=True)
            if opts:
                options.linters_params[linter] = options.linters_params.get(
                    linter, {})
                options.linters_params[linter].update(opts)

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(p.match(path) for p in options.skip):  # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = run(path, code='\n'.join(env.curbuf) + '\n', options=options)

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e._info['bufnr'] = env.curbuf.number
        if e._info['col'] is None:
            e._info['col'] = 1

    env.run('g:PymodeLocList.current().extend', [e._info for e in errors])
Example #8
0
def code_check():
    """Run pylama and check current file.

    :return bool:

    """
    with silence_stderr():

        from pylama.core import run
        from pylama.config import parse_options

        if not env.curbuf.name:
            return env.stop()

        linters = env.var('g:pymode_lint_checkers')
        env.debug(linters)

        # Fixed in v0.9.3: these two parameters may be passed as strings.
        # DEPRECATE: v:0.10.0: need to be set as lists.
        if isinstance(env.var('g:pymode_lint_ignore'), str):
            raise ValueError ('g:pymode_lint_ignore should have a list type')
        else:
            ignore = env.var('g:pymode_lint_ignore')
        if isinstance(env.var('g:pymode_lint_select'), str):
            raise ValueError ('g:pymode_lint_select should have a list type')
        else:
            select = env.var('g:pymode_lint_select')
        options = parse_options(
            linters=linters, force=1,
            ignore=ignore,
            select=select,
        )
        env.debug(options)

        for linter in linters:
            opts = env.var('g:pymode_lint_options_%s' % linter, silence=True)
            if opts:
                options.linters_params[linter] = options.linters_params.get(
                    linter, {})
                options.linters_params[linter].update(opts)

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(p.match(path) for p in options.skip):  # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = run(path, code='\n'.join(env.curbuf) + '\n', options=options)

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e._info['bufnr'] = env.curbuf.number
        if e._info['col'] is None:
            e._info['col'] = 1

    env.run('g:PymodeLocList.current().extend', [e._info for e in errors])
Example #9
0
def code_check():  # noqa
    """Run pylama and check current file.

    :return bool:

    """
    with silence_stderr():

        from pylama.core import run
        from pylama.main import parse_options
        from pylama.config import _override_options

        if not env.curbuf.name:
            return env.stop()

        options = parse_options(
            force=1,
            ignore=env.var('g:pymode_lint_ignore'),
            select=env.var('g:pymode_lint_select'),
        )

        linters = env.var('g:pymode_lint_checkers', default=[])
        if linters:
            _override_options(options, linters=",".join(linters))

            for linter in dict(options.linters):
                opts = env.var('g:pymode_lint_options_%s' % linter,
                               silence=True)
                if opts:
                    options.linters_params[
                        linter] = options.linters_params.get(linter, {})
                    options.linters_params[linter].update(opts)

        if 'pylint' in options.linters_params:
            options.linters_params['pylint']['clear_cache'] = True
        env.debug(options)

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(
                p.match(path) for p in options.skip):  # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = run(path, code='\n'.join(env.curbuf) + '\n', options=options)

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e._info['bufnr'] = env.curbuf.number
        if e._info['col'] is None:
            e._info['col'] = 1

    env.run('g:PymodeLocList.current().extend', [e._info for e in errors])
Example #10
0
def code_check():
    """Run pylama and check current file.

    :return bool:

    """
    with silence_stderr():

        from pylama.core import run
        from pylama.main import parse_options

        if not env.curbuf.name:
            return env.stop()

        linters = env.var('g:pymode_lint_checkers')
        env.debug(linters)

        options = parse_options(
            linters=linters, force=1,
            ignore=env.var('g:pymode_lint_ignore'),
            select=env.var('g:pymode_lint_select'),
        )

        for linter in linters:
            opts = env.var('g:pymode_lint_options_%s' % linter, silence=True)
            if opts:
                options.linters_params[linter] = options.linters_params.get(linter, {})
                options.linters_params[linter].update(opts)
        options.linters_params['pylint']['clear_cache'] = True

        env.debug(options)

        path = os.path.relpath(env.curbuf.name, env.curdir)
        env.debug("Start code check: ", path)

        if getattr(options, 'skip', None) and any(p.match(path) for p in options.skip):  # noqa
            env.message('Skip code checking.')
            env.debug("Skipped")
            return env.stop()

        if env.options.get('debug'):
            from pylama.core import LOGGER, logging
            LOGGER.setLevel(logging.DEBUG)

        errors = run(path, code='\n'.join(env.curbuf) + '\n', options=options)

    env.debug("Find errors: ", len(errors))
    sort_rules = env.var('g:pymode_lint_sort')

    def __sort(e):
        try:
            return sort_rules.index(e.get('type'))
        except ValueError:
            return 999

    if sort_rules:
        env.debug("Find sorting: ", sort_rules)
        errors = sorted(errors, key=__sort)

    for e in errors:
        e._info['bufnr'] = env.curbuf.number
        if e._info['col'] is None:
            e._info['col'] = 1

    env.run('g:PymodeLocList.current().extend', [e._info for e in errors])