oval_graph.command_line_client.client

Complexity

Total Complexity

38

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Test Coverage

Coverage

99%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	Client._get_message()	0	5	1
A	Client.parse_arguments()	0	8	2
A	Client.search_rules_id()	0	5	1
A	Client._get_rules()	0	4	2
A	Client._get_choices()	0	4	2
A	Client.prepare_args_rule_id()	0	5	1
A	Client.get_only_fail_rule()	0	6	1
A	Client.prepare_args_options_all_hide_passing_tests()	0	14	1
A	Client.__init__()	0	15	3
A	Client.get_questions()	0	13	1
A	Client._get_list_of_lines()	0	15	4
A	Client._get_list_of_matched_rules()	0	4	2
A	Client._get_date()	0	3	1
A	Client.get_selection_rules()	0	2	1
A	Client.prepare_args_when_user_can_list_in_rules()	0	12	1
A	Client._get_wanted_rules()	0	4	1
A	Client.prepare_parser()	0	5	1
A	Client._get_rows_of_unselected_rules()	0	5	1
A	Client.run_gui_and_return_answers()	0	12	4
A	Client.prepare_args_basic_functions()	0	18	1
A	Client.prepare_args_source_file()	0	4	1
A	Client._check_rules_id()	0	13	5

import argparse

Missing module docstring

import re
import sys
from datetime import datetime

from .. import __version__


class Client():

Missing class docstring

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

        self.source_filename = self.arg.source_filename
        self.rule_name = None
        if hasattr(self.arg, 'rule_id'):
            self.rule_name = self.arg.rule_id

        self.isatty = sys.stdout.isatty()

        self.all_rules = None
        if hasattr(self.arg, 'all'):
            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):

Missing function or method docstring

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

            try:
                import inquirer

Import outside toplevel (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):

Missing function or method docstring

        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):

Missing function or method docstring

        from inquirer.questions import Checkbox as checkbox

Import outside toplevel (inquirer.questions.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):

Missing function or method docstring

        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):

Method name "prepare_args_when_user_can_list_in_rules" doesn't conform to '[a-z_][a-z0-9_]2,30$' pattern ('[a-z_][a-z0-9_]2,30$' pattern)

Missing function or method docstring

        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.")

    @staticmethod
    def prepare_args_options_all_hide_passing_tests(parser):

Method name "prepare_args_options_all_hide_passing_tests" doesn't conform to '[a-z_][a-z0-9_]2,30$' pattern ('[a-z_][a-z0-9_]2,30$' pattern)

Missing function or method docstring

        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."))

    def prepare_args_source_file(self, parser):

Missing function or method docstring

        parser.add_argument(
            "source_filename",
            help=self._get_message().get('source_filename'))

    @staticmethod
    def prepare_args_rule_id(parser):

Missing function or method docstring

        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."))

    @staticmethod
    def prepare_args_basic_functions(parser):

Missing function or method docstring

        parser.add_argument(
            '--version',
            action='version',
            version='%(prog)s ' + __version__)
        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.')

    def prepare_parser(self, parser):

Missing function or method docstring

        self.prepare_args_basic_functions(parser)
        self.prepare_args_options_all_hide_passing_tests(parser)
        self.prepare_args_source_file(parser)
        self.prepare_args_rule_id(parser)