oval_graph.command_line_client.client.Client._check_rules_id() - Code Metrics - Inspection of "[WIP] Cli improvement" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#199)

by Jan

created 2021-06-10 14:33 UTC

Client._check_rules_id() A

↳ Parent: oval_graph.command_line_client.client

Complexity

Conditions

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	5

Importance

Changes

Metric	Value
cc	5
eloc	8
nop	3
dl	0
loc	13
ccs	6
cts	6
cp	1
crap	5
rs	9.3333
c	0
b	0
f	0

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
        self.show_not_tested_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 _get_rows_not_visualizable_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):
        rules = self.search_rules_id()
        if self.show_failed_rules:
            return {'rules': self.get_only_fail_rule(rules)}
        return {'rules': rules}

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

    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 and not self.show_not_tested_rules:
            for line in self._get_rows_of_unselected_rules():
                lines.append(line)
        if not self.show_not_selected_rules and self.show_not_tested_rules:
            for line in self._get_rows_not_visualizable_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 and not self.show_not_tested_rules:
            print("\n".join(self._get_rows_of_unselected_rules()))
        if not self.show_not_selected_rules and self.show_not_tested_rules:
            print("\n".join(self._get_rows_not_visualizable_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)]

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

OpenSCAP / oval-graph

Pull Request — master (#199)

Client._check_rules_id() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like