coalib.output.dbus.DbusDocument.Analyze() - Code Metrics - Inspection of "DbusTest: Increase number of trials to 50 (5sec)" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1865)

by Abdeali

created 2016-03-11 09:39 UTC

coalib.output.dbus.DbusDocument.Analyze() F

↳ Parent: coalib.output.dbus.DbusDocument

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	11
dl	0
loc	64
rs	3.913

How to fix Long Method Complexity

import os

import dbus.service  # Ignore PyImportSortBear

from coalib.misc.Exceptions import get_exitcode
from coalib.output.Interactions import fail_acquire_settings
from coalib.output.printers.ListLogPrinter import ListLogPrinter
from coalib.parsing.Globbing import fnmatch
from coalib.processes.Processing import execute_section
from coalib.results.HiddenResult import HiddenResult
from coalib.settings.ConfigurationGathering import (
    find_user_config, gather_configuration)
from coalib.settings.Setting import path_list


class DbusDocument(dbus.service.Object):
    interface = "org.coala_analyzer.v1"

    def __init__(self, doc_id, path=""):
        """
        Creates a new dbus object-path for every document that a
        DbusApplication wants coala to analyze. It stores the information
        (path) of the document and the config file to use when analyzing the
        given document.

        :param doc_id: An id for the document.
        :param path:   The path to the document.
        """
        dbus.service.Object.__init__(self)

        self.config_file = ""
        self.path = path
        self.doc_id = doc_id

    @dbus.service.method(interface,
                         in_signature="",
                         out_signature="s")
    def FindConfigFile(self):
        """
        This method uses the path of the document to identify a user config
        file for it

        :return: The config file path
        """
        if self.path == "":
            return ""

        self.config_file = find_user_config(self.path)
        return self.config_file

    @dbus.service.method(interface,
                         in_signature="s",
                         out_signature="s")
    def SetConfigFile(self, config_file):
        """
        This method sets the config file to use. It has to be an absolute path,
        as otherwise it is difficult to find it.

        :param config_file: The path fo the config file to use. This has to be
                            an absolute path
        :return:            The config path which has been used
        """
        self.config_file = config_file
        return self.config_file

    @dbus.service.method(interface,
                         in_signature="",
                         out_signature="s")
    def GetConfigFile(self):
        """
        This method gets the config file which is being used

        :return: The config path which is being used
        """
        return self.config_file

    # Signature explanation:
    # s -> string
    # b -> boolean
    # i -> integer (32bit)
    # a -> array (list of tuple in python)
    # () -> structure (or tuple in python)
    # a{ss} -> dictionary with string keys and string values
    @dbus.service.method(interface,
                         in_signature="",
                         out_signature="(iaa{ss}a(sbaa{ss}))")
    def Analyze(self):
        """
        This method analyzes the document and sends back the result

        :return: The output is structure which has 3 items:
                 -  The exitcode from the analysis.
                 -  List of logs from the analysis.
                 -  List of information about each section that contains:
                    -  The name of the section.
                    -  Boolean which is true if all bears in the section
                       executed successfully.
                    -  List of results where each result is a string
                       dictionary which contains:
                       id, origin, message, file, line_nr, severity
        """
        retval = []
        if self.path == "" or self.config_file == "":
            return retval

        args = ["--config=" + self.config_file]

        log_printer = ListLogPrinter()
        exitcode = 0
        try:
            yielded_results = False
            (sections,
             local_bears,
             global_bears,
             targets) = gather_configuration(fail_acquire_settings,
                                             log_printer,
                                             arg_list=args)

            for section_name in sections:
                section = sections[section_name]

                if not section.is_enabled(targets):
                    continue

                if any([fnmatch(self.path, file_pattern)
                        for file_pattern in path_list(section["files"])]):

                    section["files"].value = self.path
                    section_result = execute_section(
                        section=section,
                        global_bear_list=global_bears[section_name],
                        local_bear_list=local_bears[section_name],
                        print_results=lambda *args: True,
                        log_printer=log_printer)
                    yielded_results = yielded_results or section_result[0]

                    retval.append(
                        DbusDocument.results_to_dbus_struct(section_result,
                                                            section_name))

            if yielded_results:
                exitcode = 1
        except BaseException as exception:  # pylint: disable=broad-except
            exitcode = exitcode or get_exitcode(exception, log_printer)

        logs = [log.to_string_dict() for log in log_printer.logs]
        return (exitcode, logs, retval)

    @staticmethod
    def results_to_dbus_struct(section_result, section_name):
        """
        Converts the result tuple given by execute_section() - which has
        dictionaries and classes inside it - into a purely array based format
        as dbus protocol only allows arrays.

        :param section_result: The result tuple given by execute_section()
                               for a section
        :param section_name:   The name of the section
        :return:               The result for a section in the form of an
                               array which is sendable through dbus.
        """
        results_for_section = []
        for i in range(1, 3):  # Loop over bear types - local, global

            # Loop over every file affected for local bears
            # and every bear for global bears
            for key, value in section_result[i].items():

                # Loop over every result for a file
                results_for_section += [result.to_string_dict()
                                        for result in filter(
                        lambda x: not isinstance(x, HiddenResult),
                        value)]

        return [section_name, section_result[0], results_for_section]

    @property
    def path(self):
        return self._path

    @path.setter
    def path(self, new_path):
        if new_path:
            new_path = os.path.abspath(os.path.expanduser(new_path))
        self._path = new_path


1			import os
2
3			import dbus.service # Ignore PyImportSortBear
4
5			from coalib.misc.Exceptions import get_exitcode
6			from coalib.output.Interactions import fail_acquire_settings
7			from coalib.output.printers.ListLogPrinter import ListLogPrinter
8			from coalib.parsing.Globbing import fnmatch
9			from coalib.processes.Processing import execute_section
10			from coalib.results.HiddenResult import HiddenResult
11			from coalib.settings.ConfigurationGathering import (
12			find_user_config, gather_configuration)
13			from coalib.settings.Setting import path_list
14
15
16			class DbusDocument(dbus.service.Object):
17			interface = "org.coala_analyzer.v1"
18
19			def __init__(self, doc_id, path=""):
20			"""
21			Creates a new dbus object-path for every document that a
22			DbusApplication wants coala to analyze. It stores the information
23			(path) of the document and the config file to use when analyzing the
24			given document.
25
26			:param doc_id: An id for the document.
27			:param path: The path to the document.
28			"""
29			dbus.service.Object.__init__(self)
30
31			self.config_file = ""
32			self.path = path
33			self.doc_id = doc_id
34
35			@dbus.service.method(interface,
36			in_signature="",
37			out_signature="s")
38			def FindConfigFile(self):
39			"""
40			This method uses the path of the document to identify a user config
41			file for it
42
43			:return: The config file path
44			"""
45			if self.path == "":
46			return ""
47
48			self.config_file = find_user_config(self.path)
49			return self.config_file
50
51			@dbus.service.method(interface,
52			in_signature="s",
53			out_signature="s")
54			def SetConfigFile(self, config_file):
55			"""
56			This method sets the config file to use. It has to be an absolute path,
57			as otherwise it is difficult to find it.
58
59			:param config_file: The path fo the config file to use. This has to be
60			an absolute path
61			:return: The config path which has been used
62			"""
63			self.config_file = config_file
64			return self.config_file
65
66			@dbus.service.method(interface,
67			in_signature="",
68			out_signature="s")
69			def GetConfigFile(self):
70			"""
71			This method gets the config file which is being used
72
73			:return: The config path which is being used
74			"""
75			return self.config_file
76
77			# Signature explanation:
78			# s -> string
79			# b -> boolean
80			# i -> integer (32bit)
81			# a -> array (list of tuple in python)
82			# () -> structure (or tuple in python)
83			# a{ss} -> dictionary with string keys and string values
84			@dbus.service.method(interface,
85			in_signature="",
86			out_signature="(iaa{ss}a(sbaa{ss}))")
87			def Analyze(self):
88			"""
89			This method analyzes the document and sends back the result
90
91			:return: The output is structure which has 3 items:
92			- The exitcode from the analysis.
93			- List of logs from the analysis.
94			- List of information about each section that contains:
95			- The name of the section.
96			- Boolean which is true if all bears in the section
97			executed successfully.
98			- List of results where each result is a string
99			dictionary which contains:
100			id, origin, message, file, line_nr, severity
101			"""
102			retval = []
103			if self.path == "" or self.config_file == "":
104			return retval
105
106			args = ["--config=" + self.config_file]
107
108			log_printer = ListLogPrinter()
109			exitcode = 0
110			try:
111			yielded_results = False
112			(sections,
113			local_bears,
114			global_bears,
115			targets) = gather_configuration(fail_acquire_settings,
116			log_printer,
117			arg_list=args)
118
119			for section_name in sections:
120			section = sections[section_name]
121
122			if not section.is_enabled(targets):
123			continue
124
125			if any([fnmatch(self.path, file_pattern)
126			for file_pattern in path_list(section["files"])]):
127
128			section["files"].value = self.path
129			section_result = execute_section(
130			section=section,
131			global_bear_list=global_bears[section_name],
132			local_bear_list=local_bears[section_name],
133			print_results=lambda *args: True,
134			log_printer=log_printer)
135			yielded_results = yielded_results or section_result[0]
136
137			retval.append(
138			DbusDocument.results_to_dbus_struct(section_result,
139			section_name))
140
141			if yielded_results:
142			exitcode = 1
143			except BaseException as exception: # pylint: disable=broad-except
144			exitcode = exitcode or get_exitcode(exception, log_printer)
145
146			logs = [log.to_string_dict() for log in log_printer.logs]
147			return (exitcode, logs, retval)
148
149			@staticmethod
150			def results_to_dbus_struct(section_result, section_name):
151			"""
152			Converts the result tuple given by execute_section() - which has
153			dictionaries and classes inside it - into a purely array based format
154			as dbus protocol only allows arrays.
155
156			:param section_result: The result tuple given by execute_section()
157			for a section
158			:param section_name: The name of the section
159			:return: The result for a section in the form of an
160			array which is sendable through dbus.
161			"""
162			results_for_section = []
163			for i in range(1, 3): # Loop over bear types - local, global
164
165			# Loop over every file affected for local bears
166			# and every bear for global bears
167			for key, value in section_result[i].items():
168
169			# Loop over every result for a file
170			results_for_section += [result.to_string_dict()
171			for result in filter(
172			lambda x: not isinstance(x, HiddenResult),
173			value)]
174
175			return [section_name, section_result[0], results_for_section]
176
177			@property
178			def path(self):
179			return self._path
180
181			@path.setter
182			def path(self, new_path):
183			if new_path:
184			new_path = os.path.abspath(os.path.expanduser(new_path))
185			self._path = new_path
186

coala-analyzer / coala

Pull Request — master (#1865)

coalib.output.dbus.DbusDocument.Analyze() F

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like