DocumentationComment._parse_documentation_with_symbols() - Code Metrics - Inspection of "Sanketdg/assemble" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2423)

unknown

created 2016-07-16 20:21 UTC

_parse_documentation_with_symbols() C

↳ Parent: DocumentationComment

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	7
c	2
b	0
f	0
dl	0
loc	65
rs	6.0105

How to fix Long Method

from collections import namedtuple

from coala_decorators.decorators import generate_eq, generate_repr


@generate_repr()
@generate_eq("documentation", "language", "docstyle",
             "indent", "marker", "range")
class DocumentationComment:
    """
    The DocumentationComment holds information about a documentation comment
    inside source-code, like position etc.
    """
    Parameter = namedtuple('Parameter', 'name, desc')
    ReturnValue = namedtuple('ReturnValue', 'desc')
    Description = namedtuple('Description', 'desc')

    def __init__(self, documentation, docstyle_definition,
                 indent, marker, range):
        """
        Instantiates a new DocumentationComment.

        :param documentation: The documentation text.
        :param language:      The language of the documention.
        :param docstyle:      The docstyle used in the documentation.
        :param indent:        The string of indentation used in front
                              of the first marker of the documentation.
        :param marker:        The three-element tuple with marker strings,
                              that identified this documentation comment.
        :param range:         The position range of type TextRange.
        """
        self.documentation = documentation
        self.docstyle_definition = docstyle_definition
        self.indent = indent
        self.marker = marker
        self.range = range

    def __str__(self):
        return self.documentation

    @property
    def language(self):
        return self.docstyle_definition.language.lower()

    @property
    def docstyle(self):
        return self.docstyle_definition.docstyle.lower()

    @property
    def metdata(self):
        return self.docstyle_definition.metadata

    def parse(self):
        """
        Parses documentation independent of language and docstyle.

        :return:
            The list of all the parsed sections of the documentation. Every
            section is a namedtuple of either ``Description`` or ``Parameter``
            or ``ReturnValue``.
        :raises NotImplementedError:
            When no parsing method is present for the given language and
            docstyle.
        """
        if self.language == "python" and self.docstyle == "default":
            return self._parse_documentation_with_symbols(
                (":param ", ":"), ":return:")
        elif self.language == "python" and self.docstyle == "doxygen":
            return self._parse_documentation_with_symbols(
                ("@param ", " "), "@return ")
        elif self.language == "java" and self.docstyle == "default":
            return self._parse_documentation_with_symbols(
                ("@param  ", " "), "@return ")
        else:
            raise NotImplementedError(
                "Documentation parsing for {0.language!r} in {0.docstyle!r}"
                " has not been implemented yet".format(self))

    def _parse_documentation_with_symbols(self, param_identifiers,
                                          return_identifiers):
        """
        Parses documentation based on parameter and return symbols.

        :param param_identifiers:
            A tuple of two strings with which a parameter starts and ends.
        :param return_identifiers:
            The string with which a return description starts.
        :return:
            The list of all the parsed sections of the documentation. Every
            section is a namedtuple of either ``Description`` or ``Parameter``
            or ``ReturnValue``.
        """
        lines = self.documentation.splitlines(keepends=True)

        parse_mode = self.Description

        cur_param = ""

        desc = ""
        parsed = []

        for line in lines:

            stripped_line = line.strip()

            if stripped_line.startswith(param_identifiers[0]):
                parse_mode = self.Parameter
                param_offset = line.find(
                    param_identifiers[0]) + len(param_identifiers[0])
                splitted = line[param_offset:].split(param_identifiers[1], 1)
                cur_param = splitted[0].strip()

                param_desc = splitted[1]
                parsed.append(self.Parameter(name=cur_param, desc=param_desc))

            elif stripped_line.startswith(return_identifiers):
                parse_mode = self.ReturnValue
                return_offset = line.find(
                    return_identifiers) + len(return_identifiers)
                retval_desc = line[return_offset:]
                parsed.append(self.ReturnValue(desc=retval_desc))

            elif parse_mode == self.ReturnValue:
                retval_desc += line
                parsed.pop()
                parsed.append(self.ReturnValue(desc=retval_desc))

            elif parse_mode == self.Parameter:
                param_desc += line
                parsed.pop()
                parsed.append(self.Parameter(name=cur_param, desc=param_desc))

            else:
                desc += line
                # This is inside a try-except for cases where the list
                # is empty and has nothing to pop.
                try:
                    parsed.pop()
                except IndexError:
                    pass
                parsed.append(self.Description(desc=desc))

        return parsed


1			from collections import namedtuple
2
3			from coala_decorators.decorators import generate_eq, generate_repr
4
5
6			@generate_repr()
7			@generate_eq("documentation", "language", "docstyle",
8			"indent", "marker", "range")
9			class DocumentationComment:
10			"""
11			The DocumentationComment holds information about a documentation comment
12			inside source-code, like position etc.
13			"""
14			Parameter = namedtuple('Parameter', 'name, desc')
15			ReturnValue = namedtuple('ReturnValue', 'desc')
16			Description = namedtuple('Description', 'desc')
17
18			def __init__(self, documentation, docstyle_definition,
19			indent, marker, range):
20			"""
21			Instantiates a new DocumentationComment.
22
23			:param documentation: The documentation text.
24			:param language: The language of the documention.
25			:param docstyle: The docstyle used in the documentation.
26			:param indent: The string of indentation used in front
27			of the first marker of the documentation.
28			:param marker: The three-element tuple with marker strings,
29			that identified this documentation comment.
30			:param range: The position range of type TextRange.
31			"""
32			self.documentation = documentation
33			self.docstyle_definition = docstyle_definition
34			self.indent = indent
35			self.marker = marker
36			self.range = range
37
38			def __str__(self):
39			return self.documentation
40
41			@property
42			def language(self):
43			return self.docstyle_definition.language.lower()
44
45			@property
46			def docstyle(self):
47			return self.docstyle_definition.docstyle.lower()
48
49			@property
50			def metdata(self):
51			return self.docstyle_definition.metadata
52
53			def parse(self):
54			"""
55			Parses documentation independent of language and docstyle.
56
57			:return:
58			The list of all the parsed sections of the documentation. Every
59			section is a namedtuple of either ``Description`` or ``Parameter``
60			or ``ReturnValue``.
61			:raises NotImplementedError:
62			When no parsing method is present for the given language and
63			docstyle.
64			"""
65			if self.language == "python" and self.docstyle == "default":
66			return self._parse_documentation_with_symbols(
67			(":param ", ":"), ":return:")
68			elif self.language == "python" and self.docstyle == "doxygen":
69			return self._parse_documentation_with_symbols(
70			("@param ", " "), "@return ")
71			elif self.language == "java" and self.docstyle == "default":
72			return self._parse_documentation_with_symbols(
73			("@param ", " "), "@return ")
74			else:
75			raise NotImplementedError(
76			"Documentation parsing for {0.language!r} in {0.docstyle!r}"
77			" has not been implemented yet".format(self))
78
79			def _parse_documentation_with_symbols(self, param_identifiers,
80			return_identifiers):
81			"""
82			Parses documentation based on parameter and return symbols.
83
84			:param param_identifiers:
85			A tuple of two strings with which a parameter starts and ends.
86			:param return_identifiers:
87			The string with which a return description starts.
88			:return:
89			The list of all the parsed sections of the documentation. Every
90			section is a namedtuple of either ``Description`` or ``Parameter``
91			or ``ReturnValue``.
92			"""
93			lines = self.documentation.splitlines(keepends=True)
94
95			parse_mode = self.Description
96
97			cur_param = ""
98
99			desc = ""
100			parsed = []
101
102			for line in lines:
103
104			stripped_line = line.strip()
105
106			if stripped_line.startswith(param_identifiers[0]):
107			parse_mode = self.Parameter
108			param_offset = line.find(
109			param_identifiers[0]) + len(param_identifiers[0])
110			splitted = line[param_offset:].split(param_identifiers[1], 1)
111			cur_param = splitted[0].strip()
112
113			param_desc = splitted[1]
114			parsed.append(self.Parameter(name=cur_param, desc=param_desc))
115
116			elif stripped_line.startswith(return_identifiers):
117			parse_mode = self.ReturnValue
118			return_offset = line.find(
119			return_identifiers) + len(return_identifiers)
120			retval_desc = line[return_offset:]
121			parsed.append(self.ReturnValue(desc=retval_desc))
122
123			elif parse_mode == self.ReturnValue:
124			retval_desc += line
125			parsed.pop()
126			parsed.append(self.ReturnValue(desc=retval_desc))
127
128			elif parse_mode == self.Parameter:
129			param_desc += line
130			parsed.pop()
131			parsed.append(self.Parameter(name=cur_param, desc=param_desc))
132
133			else:
134			desc += line
135			# This is inside a try-except for cases where the list
136			# is empty and has nothing to pop.
137			try:
138			parsed.pop()
139			except IndexError:
140			pass
141			parsed.append(self.Description(desc=desc))
142
143			return parsed
144

coala-analyzer / coala

Pull Request — master (#2423)

_parse_documentation_with_symbols() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like