oval_graph.command_line_client.client.Client._get_wanted_rules() - Code Metrics - Inspection of "[WIP] Rework of ARF XML parser" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#187)

by Jan

created 2021-06-14 11:10 UTC

Client._get_wanted_rules() A

↳ Parent: oval_graph.command_line_client.client

Complexity

Conditions

Size

Total Lines	4
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nop	2
crap	2

import argparse
import re
import sys
from datetime import datetime

from .. import __version__


class Client():
    def __init__(self, args):
        self.arg = self.parse_arguments(args)

        self.source_filename = self.arg.source_filename
        self.rule_name = self.arg.rule_id

        self.isatty = sys.stdout.isatty()

        self.all_rules = self.arg.all
        self.show_failed_rules = False
        self.show_not_selected_rules = False

    @staticmethod
    def _get_message():
        return {
            'description': '',
            'source_filename': '',
        }

    @staticmethod
    def _get_date():
        return str(datetime.now().strftime("-%d_%m_%Y-%H_%M_%S"))

    # Functions for selection of rules

    def search_rules_id(self):
        """
        Function retunes array of all matched IDs of rules in selected file.
        """
        raise NotImplementedError

    def get_only_fail_rule(self, rules):
        """
        Function processes array of matched IDs of rules in selected file.
        Function retunes array of failed matched IDs of rules in selected file.
        """
        raise NotImplementedError

    def _get_rows_of_unselected_rules(self):
        """
        Function retunes array of rows where is not selected IDs of rules in selected file.
        """
        raise NotImplementedError

    def run_gui_and_return_answers(self):
        if self.isatty:
            if self.all_rules:
                return self._get_rules()

            try:
                import inquirer

                return inquirer.prompt(self.get_questions())
            except ImportError:
                print(self.get_selection_rules())
            return None
        return self._get_rules()

    def _get_rules(self):
        if self.show_failed_rules:
            return {'rules': self.get_only_fail_rule(self.search_rules_id())}
        return {'rules': self.search_rules_id()}

    def _get_list_of_matched_rules(self):
        if self.show_failed_rules:
            return self.get_only_fail_rule(self.search_rules_id())
        return self.search_rules_id()

    def _get_list_of_lines(self):
        lines = ['== The Rule ID regular expressions ==']
        for rule in self._get_list_of_matched_rules():
            lines.append("^" + rule + "$")
        if self.show_not_selected_rules:
            for line in self._get_rows_of_unselected_rules():
                lines.append(line)
        lines.append(
            "Interactive rule selection is not available,"
            " because inquirer is not installed."
            " Copy id of the rule you want to visualize and"
            " paste it into a command with regular"
            " expression characters(^$).\n"
            "Alternatively, use the --all or --all-in-one arguments.")
        return lines

    def get_selection_rules(self):
        return "\n".join(self._get_list_of_lines())

    def _get_choices(self):
        if self.show_not_selected_rules:
            print("\n".join(self._get_rows_of_unselected_rules()))
        return self._get_list_of_matched_rules()

    def get_questions(self):
        from inquirer.questions import Checkbox as checkbox

        choices = self._get_choices()
        questions = [
            checkbox(
                'rules',
                message=(
                    "= The Rules IDs = (move - UP and DOWN arrows,"
                    " select - SPACE or LEFT and RIGHT arrows, submit - ENTER)"),
                choices=choices,
            ),
        ]
        return questions

    def _get_wanted_rules(self, rules):
        return [
            x for x in rules if re.search(
                self.rule_name, x)]

    def _check_rules_id(self, rules, notselected_rules):
        if notselected_rules and not rules:
            raise ValueError(
                ('Rule(s) "{}" was not selected, '
                 "so there are no results. The rule is"
                 ' "notselected" because it'
                 " wasn't a part of the executed profile"
                 " and therefore it wasn't evaluated "
                 "during the scan.")
                .format(notselected_rules))
        if not notselected_rules and not rules:
            raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
        return rules

    # Function for setting arguments

    def parse_arguments(self, args):
        parser = argparse.ArgumentParser(
            prog='oval-graph',
            description=self._get_message().get('description'))
        self.prepare_parser(parser)
        if args is None:
            return parser.parse_args()
        return parser.parse_args(args)

    @staticmethod
    def prepare_args_when_user_can_list_in_rules(parser):
        parser.add_argument(
            '--show-failed-rules',
            action="store_true",
            default=False,
            help="Show only FAILED rules")
        parser.add_argument(
            '--show-not-selected-rules',
            action="store_true",
            default=False,
            help="Show notselected rules. These rules will not be visualized.")

    def prepare_parser(self, parser):
        parser.add_argument(
            '--version',
            action='version',
            version='%(prog)s ' + __version__)
        parser.add_argument(
            '-a',
            '--all',
            action="store_true",
            default=False,
            help="Process all matched rules.")
        parser.add_argument(
            '--hide-passing-tests',
            action="store_true",
            default=False,
            help=(
                "Do not display passing tests for better orientation in"
                " graphs that contain a large amount of nodes."))
        parser.add_argument(
            '-v',
            '--verbose',
            action="store_true",
            default=False,
            help="Displays details about the results of the running command.")
        parser.add_argument(
            '-o',
            '--output',
            action="store",
            default=None,
            help='The file where to save output.')
        parser.add_argument(
            "source_filename",
            help=self._get_message().get('source_filename'))
        parser.add_argument(
            "rule_id", help=(
                "Rule ID to be visualized. A part from the full rule ID"
                " a part of the ID or a regular expression can be used."
                " If brackets are used in the regular expression "
                "the regular expression must be quoted."))


1			import argparse
2			import re
3			import sys
4			from datetime import datetime
5
6			from .. import __version__
7
8
9			class Client():
10			def __init__(self, args):
11			self.arg = self.parse_arguments(args)
12
13			self.source_filename = self.arg.source_filename
14			self.rule_name = self.arg.rule_id
15
16			self.isatty = sys.stdout.isatty()
17
18			self.all_rules = self.arg.all
19			self.show_failed_rules = False
20			self.show_not_selected_rules = False
21
22			@staticmethod
23			def _get_message():
24			return {
25			'description': '',
26			'source_filename': '',
27			}
28
29			@staticmethod
30			def _get_date():
31			return str(datetime.now().strftime("-%d_%m_%Y-%H_%M_%S"))
32
33			# Functions for selection of rules
34
35			def search_rules_id(self):
36			"""
37			Function retunes array of all matched IDs of rules in selected file.
38			"""
39			raise NotImplementedError
40
41			def get_only_fail_rule(self, rules):
42			"""
43			Function processes array of matched IDs of rules in selected file.
44			Function retunes array of failed matched IDs of rules in selected file.
45			"""
46			raise NotImplementedError
47
48			def _get_rows_of_unselected_rules(self):
49			"""
50			Function retunes array of rows where is not selected IDs of rules in selected file.
51			"""
52			raise NotImplementedError
53
54			def run_gui_and_return_answers(self):
55			if self.isatty:
56			if self.all_rules:
57			return self._get_rules()
58
59			try:
60			import inquirer
			0 ignored issues – show introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Import outside toplevel (inquirer) Loading history...
61			return inquirer.prompt(self.get_questions())
62			except ImportError:
63			print(self.get_selection_rules())
64			return None
65			return self._get_rules()
66
67			def _get_rules(self):
68			if self.show_failed_rules:
69			return {'rules': self.get_only_fail_rule(self.search_rules_id())}
70			return {'rules': self.search_rules_id()}
71
72			def _get_list_of_matched_rules(self):
73			if self.show_failed_rules:
74			return self.get_only_fail_rule(self.search_rules_id())
75			return self.search_rules_id()
76
77			def _get_list_of_lines(self):
78			lines = ['== The Rule ID regular expressions ==']
79			for rule in self._get_list_of_matched_rules():
80			lines.append("^" + rule + "$")
81			if self.show_not_selected_rules:
82			for line in self._get_rows_of_unselected_rules():
83			lines.append(line)
84			lines.append(
85			"Interactive rule selection is not available,"
86			" because inquirer is not installed."
87			" Copy id of the rule you want to visualize and"
88			" paste it into a command with regular"
89			" expression characters(^$).\n"
90			"Alternatively, use the --all or --all-in-one arguments.")
91			return lines
92
93			def get_selection_rules(self):
94			return "\n".join(self._get_list_of_lines())
95
96			def _get_choices(self):
97			if self.show_not_selected_rules:
98			print("\n".join(self._get_rows_of_unselected_rules()))
99			return self._get_list_of_matched_rules()
100
101			def get_questions(self):
102			from inquirer.questions import Checkbox as checkbox
			0 ignored issues – show introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Import outside toplevel (inquirer.questions.Checkbox) Loading history...
103			choices = self._get_choices()
104			questions = [
105			checkbox(
106			'rules',
107			message=(
108			"= The Rules IDs = (move - UP and DOWN arrows,"
109			" select - SPACE or LEFT and RIGHT arrows, submit - ENTER)"),
110			choices=choices,
111			),
112			]
113			return questions
114
115			def _get_wanted_rules(self, rules):
116			return [
117			x for x in rules if re.search(
118			self.rule_name, x)]
119
120			def _check_rules_id(self, rules, notselected_rules):
121			if notselected_rules and not rules:
122			raise ValueError(
123			('Rule(s) "{}" was not selected, '
124			"so there are no results. The rule is"
125			' "notselected" because it'
126			" wasn't a part of the executed profile"
127			" and therefore it wasn't evaluated "
128			"during the scan.")
129			.format(notselected_rules))
130			if not notselected_rules and not rules:
131			raise ValueError('404 rule "{}" not found!'.format(self.rule_name))
132			return rules
133
134			# Function for setting arguments
135
136			def parse_arguments(self, args):
137			parser = argparse.ArgumentParser(
138			prog='oval-graph',
139			description=self._get_message().get('description'))
140			self.prepare_parser(parser)
141			if args is None:
142			return parser.parse_args()
143			return parser.parse_args(args)
144
145			@staticmethod
146			def prepare_args_when_user_can_list_in_rules(parser):
147			parser.add_argument(
148			'--show-failed-rules',
149			action="store_true",
150			default=False,
151			help="Show only FAILED rules")
152			parser.add_argument(
153			'--show-not-selected-rules',
154			action="store_true",
155			default=False,
156			help="Show notselected rules. These rules will not be visualized.")
157
158			def prepare_parser(self, parser):
159			parser.add_argument(
160			'--version',
161			action='version',
162			version='%(prog)s ' + __version__)
163			parser.add_argument(
164			'-a',
165			'--all',
166			action="store_true",
167			default=False,
168			help="Process all matched rules.")
169			parser.add_argument(
170			'--hide-passing-tests',
171			action="store_true",
172			default=False,
173			help=(
174			"Do not display passing tests for better orientation in"
175			" graphs that contain a large amount of nodes."))
176			parser.add_argument(
177			'-v',
178			'--verbose',
179			action="store_true",
180			default=False,
181			help="Displays details about the results of the running command.")
182			parser.add_argument(
183			'-o',
184			'--output',
185			action="store",
186			default=None,
187			help='The file where to save output.')
188			parser.add_argument(
189			"source_filename",
190			help=self._get_message().get('source_filename'))
191			parser.add_argument(
192			"rule_id", help=(
193			"Rule ID to be visualized. A part from the full rule ID"
194			" a part of the ID or a regular expression can be used."
195			" If brackets are used in the regular expression "
196			"the regular expression must be quoted."))
197

OpenSCAP / oval-graph

Pull Request — master (#187)

Client._get_wanted_rules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like