Bear

Complexity

Total Complexity

23

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	execute()	0	17	2
A	get_non_optional_settings()	0	12	1
A	get_config_dir()	0	7	1
A	log_message()	0	3	2
A	check_prerequisites()	0	14	1
A	_print()	0	2	1
B	__init__()	0	35	5
A	get_dependencies()	0	12	1
A	run_bear_from_section()	0	10	2
A	missing_dependencies()	0	16	3
A	name()	0	6	1
A	kind()	0	6	1
A	get_metadata()	0	10	1
A	run()	0	2	1

import traceback

from pyprint.Printer import Printer

from coalib.misc.Decorators import enforce_signature, classproperty
from coalib.output.printers.LogPrinter import LogPrinter
from coalib.settings.FunctionMetadata import FunctionMetadata
from coalib.settings.Section import Section
from coalib.settings.ConfigurationGathering import get_config_directory


class Bear(Printer, LogPrinter):

The variable Printer does not seem to be defined.

The variable LogPrinter does not seem to be defined.

    """
    A bear contains the actual subroutine that is responsible for checking
    source code for certain specifications. However it can actually do
    whatever it wants with the files it gets. If you are missing some Result
    type, feel free to contact us and/or help us extending the coalib.

    This is the base class for every bear. If you want to write an bear, you
    will probably want to look at the GlobalBear and LocalBear classes that
    inherit from this class. In any case you'll want to overwrite at least the
    run method. You can send debug/warning/error messages through the
    debug(), warn(), err() functions. These will send the
    appropriate messages so that they are outputted. Be aware that if you use
    err(), you are expected to also terminate the bear run-through
    immediately.

    If you need some setup or teardown for your bear, feel free to overwrite
    the set_up() and tear_down() functions. They will be invoked
    before/after every run invocation.

    Settings are available at all times through self.section.

    To indicate which languages your bear supports, just give it the
    ``LANGUAGES`` value which can either be a string (if the bear supports
    only 1 language) or a tuple of strings:

    >>> class SomeBear(Bear):
    ...     LANGUAGES = ('C', 'CPP','C#', 'D')

    >>> class SomeBear(Bear):
    ...     LANGUAGES = "Java"
    """

    LANGUAGES = ()

    @classproperty

The variable classproperty does not seem to be defined.

    def name(cls):
        """
        :return: The name of the bear
        """
        return cls.__name__

The variable cls does not seem to be defined.

    @enforce_signature

The variable enforce_signature does not seem to be defined.

    def __init__(self,
                 section: Section,

The variable Section does not seem to be defined.

                 message_queue,
                 timeout=0):
        """
        Constructs a new bear.

        :param section:       The section object where bear settings are
                              contained.
        :param message_queue: The queue object for messages. Can be ``None``.
        :param timeout:       The time the bear is allowed to run. To set no
                              time limit, use 0.
        :raises TypeError:    Raised when ``message_queue`` is no queue.
        :raises RuntimeError: Raised when bear requirements are not fulfilled.
        """
        Printer.__init__(self)

The variable self does not seem to be defined.

        LogPrinter.__init__(self, self)

        if message_queue is not None and not hasattr(message_queue, "put"):

The variable message_queue does not seem to be defined.

            raise TypeError("message_queue has to be a Queue or None.")

        self.section = section

The variable section does not seem to be defined.

        self.message_queue = message_queue
        self.timeout = timeout

The variable timeout does not seem to be defined.

        cp = type(self).check_prerequisites()
        if cp is not True:

The variable cp does not seem to be defined.

            error_string = ("The bear " + self.name +
                            " does not fulfill all requirements.")
            if cp is not False:
                error_string += " " + cp

The variable error_string does not seem to be defined.

            self.warn(error_string)
            raise RuntimeError(error_string)

    def _print(self, output, **kwargs):
        self.debug(output)

The variable output does not seem to be defined.

    def log_message(self, log_message, timestamp=None, **kwargs):
        if self.message_queue is not None:

The variable self does not seem to be defined.

            self.message_queue.put(log_message)

The variable log_message does not seem to be defined.

    def run(self, *args, dependency_results=None, **kwargs):
        raise NotImplementedError

The variable NotImplementedError does not seem to be defined.

    def run_bear_from_section(self, args, kwargs):
        try:
            kwargs.update(
                self.get_metadata().create_params_from_section(self.section))

The variable self does not seem to be defined.

        except ValueError as err:

The variable ValueError does not seem to be defined.

            self.warn("The bear {} cannot be executed.".format(
                self.name), str(err))

The variable err does not seem to be defined.

            return

        return self.run(*args, **kwargs)

The variable args does not seem to be defined.

The variable kwargs does not seem to be defined.

    def execute(self, *args, **kwargs):
        name = self.name

The variable self does not seem to be defined.

        try:
            self.debug("Running bear {}...".format(name))

The variable name does not seem to be defined.

            # If it's already a list it won't change it
            return list(self.run_bear_from_section(args, kwargs) or [])

The variable kwargs does not seem to be defined.

The variable args does not seem to be defined.

        except:
            self.warn(
                "Bear {} failed to run. Take a look at debug messages for "
                "further information.".format(name))
            self.debug(
                "The bear {bear} raised an exception. If you are the writer "
                "of this bear, please make sure to catch all exceptions. If "
                "not and this error annoys you, you might want to get in "
                "contact with the writer of this bear.\n\nTraceback "
                "information is provided below:\n\n{traceback}"
                "\n".format(bear=name, traceback=traceback.format_exc()))

    @staticmethod

The variable staticmethod does not seem to be defined.

    def kind():
        """
        :return: The kind of the bear
        """
        raise NotImplementedError

The variable NotImplementedError does not seem to be defined.

    @classmethod

The variable classmethod does not seem to be defined.

    def get_metadata(cls):
        """
        :return: Metadata for the run function. However parameters like
                 ``self`` or parameters implicitly used by coala (e.g.
                 filename for local bears) are already removed.
        """
        return FunctionMetadata.from_function(
            cls.run,

The variable cls does not seem to be defined.

            omit={"self", "dependency_results"})

    @classmethod

The variable classmethod does not seem to be defined.

    def missing_dependencies(cls, lst):
        """
        Checks if the given list contains all dependencies.

        :param lst: A list of all already resolved bear classes (not
                    instances).
        :return:    A list of missing dependencies.
        """
        dep_classes = cls.get_dependencies()

        for item in lst:

The variable lst does not seem to be defined.

            if item in dep_classes:

The variable item does not seem to be defined.

                dep_classes.remove(item)

        return dep_classes

The variable dep_classes does not seem to be defined.

    @staticmethod

The variable staticmethod does not seem to be defined.

    def get_dependencies():
        """
        Retrieves bear classes that are to be executed before this bear gets
        executed. The results of these bears will then be passed to the
        run method as a dict via the dependency_results argument. The dict
        will have the name of the Bear as key and the list of its results as
        results.

        :return: A list of bear classes.
        """
        return []

    @classmethod

The variable classmethod does not seem to be defined.

    def get_non_optional_settings(cls):
        """
        This method has to determine which settings are needed by this bear.
        The user will be prompted for needed settings that are not available
        in the settings file so don't include settings where a default value
        would do.

        :return: A dictionary of needed settings as keys and a tuple of help
                 text and annotation as values
        """
        return cls.get_metadata().non_optional_params

    @classmethod

The variable classmethod does not seem to be defined.

    def check_prerequisites(cls):
        """
        Checks whether needed runtime prerequisites of the bear are satisfied.

        This function gets executed at construction and returns True by
        default.

        Section value requirements shall be checked inside the ``run`` method.

        :return: True if prerequisites are satisfied, else False or a string
                 that serves a more detailed description of what's missing.
        """
        return True

    def get_config_dir(self):
        """
        Gives the directory where the configuration file is

        :return: Directory of the config file
        """
        return get_config_directory(self.section)

The variable self does not seem to be defined.