coala-analyzer / coala

coalib/parsing/LineParser.py

from coalib.misc.StringConverter import StringConverter
from coalib.parsing.StringProcessing import unescape, convert_to_raw


class LineParser:

    def __init__(self,
                 key_value_delimiters=('=',),
                 comment_seperators=('#',),
                 key_delimiters=(',', ' '),
                 section_name_surroundings=None,
                 section_override_delimiters=(".",)):
        """
        Creates a new line parser. Please note that no delimiter or seperator
        may be an "o" or you may encounter undefined behaviour with the
        escapes.

        :param key_value_delimiters:        Delimiters that delimit a key from
                                            a value
        :param comment_seperators:          Used to initiate a comment
        :param key_delimiters:              Delimiters between several keys
        :param section_name_surroundings:   Dictionary, e.g. {"[", "]"} means a
                                            section name is surrounded by [].
                                            If None, {"[": "]"} is used as
                                            default.
        :param section_override_delimiters: Delimiter for a section override.
                                            E.g. "." would mean that
                                            section.key is a possible key that
                                            puts the key into the section
                                            "section" despite of the current
                                            section.
        """
        section_name_surroundings = section_name_surroundings or {"[": "]"}

The variable section_name_surroundings does not seem to be defined.

        self.key_value_delimiters = key_value_delimiters

The variable key_value_delimiters does not seem to be defined.

        self.comment_seperators = comment_seperators

The variable comment_seperators does not seem to be defined.

        self.key_delimiters = key_delimiters

The variable key_delimiters does not seem to be defined.

        self.section_name_surroundings = section_name_surroundings
        self.section_override_delimiters = section_override_delimiters

The variable section_override_delimiters does not seem to be defined.

    def parse(self, line):
        """
        Note that every value in the returned touple *besides the value* is
        unescaped. This is so since the value is meant to be put into a Setting
        later thus the escapes may be needed there.

        :param line: the line to parse
        :return:     section_name (empty string if it's no section name),
                     [(section_override, key), ...], value, comment
        """
        line, comment = self.__seperate_by_first_occurrence(
            line,

The variable line does not seem to be defined.

            self.comment_seperators)

The variable self does not seem to be defined.

        comment = unescape(comment)

The variable comment does not seem to be defined.

        if line == "":
            return '', [], '', comment

        section_name = unescape(self.__get_section_name(line))
        if section_name != '':

The variable section_name does not seem to be defined.

            return section_name, [], '', comment

        # Escapes in value might be needed by the bears
        keys, value = self.__extract_keys_and_value(line)

        # Add all the delimiters that stored as tuples
        all_delimiters = self.key_value_delimiters
        all_delimiters += self.key_delimiters

The variable all_delimiters does not seem to be defined.

        all_delimiters += self.comment_seperators
        all_delimiters += self.section_override_delimiters
        all_delimiters = "".join(all_delimiters)

        # Add all keys and values in section_name_surroundings, which is
        # stored as a dict
        all_delimiters += "".join(self.section_name_surroundings.keys())
        all_delimiters += "".join(self.section_name_surroundings.values())

        value = convert_to_raw(value, all_delimiters)

The variable value does not seem to be defined.

        key_touples = []
        for key in keys:

The variable keys does not seem to be defined.

            key = convert_to_raw(key, all_delimiters)

The variable key does not seem to be defined.

            section, key = self.__seperate_by_first_occurrence(
                key,
                self.section_override_delimiters,
                True,
                True)
            key_touples.append((unescape(section), unescape(key)))

The variable section does not seem to be defined.

        return '', key_touples, value, comment

The variable key_touples does not seem to be defined.

    @staticmethod

The variable staticmethod does not seem to be defined.

    def __seperate_by_first_occurrence(string,
                                       delimiters,
                                       strip_delim=False,
                                       return_second_part_nonempty=False):
        """
        Seperates a string by the first of all given delimiters. Any whitespace
        characters will be stripped away from the parts.

        :param string:                      The string to seperate.
        :param delimiters:                  The delimiters.
        :param strip_delim:                 Strips the delimiter from the
                                            result if true.
        :param return_second_part_nonempty: If no delimiter is found and this
                                            is true the contents of the string
                                            will be returned in the second part
                                            of the touple instead of the first
                                            one.
        :return:                            (first_part, second_part)
        """
        temp_string = string.replace("\\\\", "oo")
        i = temp_string.find("\\")
        while i != -1:

The variable i does not seem to be defined.

            temp_string = temp_string[:i] + "oo" + temp_string[i+2:]

The variable temp_string does not seem to be defined.

            i = temp_string.find("\\", i+2)

        delim_pos = len(string)

The variable string does not seem to be defined.

        used_delim = ""
        for delim in delimiters:

The variable delimiters does not seem to be defined.

            pos = temp_string.find(delim)

The variable delim does not seem to be defined.

            if 0 <= pos < delim_pos:
                delim_pos = pos

The variable pos does not seem to be defined.

                used_delim = delim

        if return_second_part_nonempty and delim_pos == len(string):

The variable return_second_part_nonempty does not seem to be defined.

The variable delim_pos does not seem to be defined.

            return "", string.strip(" \n")

        return (
            string[:delim_pos].strip(" \n"),
            string[delim_pos + (len(used_delim) if strip_delim else 0):].strip(
                " \n"))

    def __get_section_name(self, line):
        for begin, end in self.section_name_surroundings.items():
            if (line[0:len(begin)] == begin and

The variable begin does not seem to be defined.

The variable line does not seem to be defined.

                    line[len(line) - len(end):len(line)] == end):

The variable end does not seem to be defined.

                return line[len(begin):len(line) - len(end)].strip(" \n")

        return ''

    def __extract_keys_and_value(self, line):
        key_part, value = self.__seperate_by_first_occurrence(
            line,

The variable line does not seem to be defined.

            self.key_value_delimiters,

The variable self does not seem to be defined.

            True,
            True)
        keys = list(StringConverter(
            key_part,
            list_delimiters=self.key_delimiters).__iter__(
            remove_backslashes=False))

        return keys, value

The variable keys does not seem to be defined.

The variable value does not seem to be defined.