oval_graph.command_line_client.client_html_output

Complexity

Total Complexity

24

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Test Coverage

Coverage

88.24%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	ClientHtmlOutput.prepare_data()	0	6	1
A	ClientHtmlOutput.get_src()	0	4	1
A	ClientHtmlOutput._build_and_save_html()	0	3	1
A	ClientHtmlOutput.kill_web_browsers()	0	3	2
B	ClientHtmlOutput._prepare_data()	0	20	5
A	ClientHtmlOutput.get_start_of_file_name()	0	3	1
A	ClientHtmlOutput._put_to_dict_oval_trees()	0	6	1
A	ClientHtmlOutput.__init__()	0	10	4
A	ClientHtmlOutput.arg_all_in_one()	0	8	1
A	ClientHtmlOutput.arg_display()	0	8	1
A	ClientHtmlOutput.get_save_src()	0	9	2
A	ClientHtmlOutput._get_src_for_one_graph()	0	2	1
A	ClientHtmlOutput.open_results_in_web_browser()	0	9	3

import os

Missing module docstring

import subprocess
import tempfile
import webbrowser

from .._builder_html_graph import BuilderHtmlGraph
from ..exceptions import NotChecked
from .client import Client


class ClientHtmlOutput(Client):

Missing class docstring

    def __init__(self, args):
        super().__init__(args)
        self.out = self.arg.output
        self.part = self.get_src('../parts')
        if hasattr(self.arg, 'all_in_one'):
            self.all_in_one = self.arg.all_in_one
            self.all_rules = True if self.all_in_one else self.arg.all
            self.html_builder = BuilderHtmlGraph(self.part, self.arg.verbose, self.all_in_one)
        self.display_html = True if self.out is None else self.arg.display
        self.web_browsers = []

    @staticmethod
    def get_src(src):

Missing function or method docstring

        _dir = os.path.dirname(os.path.realpath(__file__))
        return str(os.path.join(_dir, src))

    @staticmethod
    def get_start_of_file_name():

Missing function or method docstring

        return 'graph-of-'

    def prepare_data(self, rules):

Missing function or method docstring

        out_src = []
        oval_tree_dict = dict()
        self._prepare_data(rules, oval_tree_dict, out_src)
        self.open_results_in_web_browser(out_src)
        return out_src

    def _put_to_dict_oval_trees(self, dict_oval_trees, rule):
        """
        The function inserts into dict_oval_trees a dictionary from
        the rule with the key as the rule id.
        """
        raise NotImplementedError

    def _prepare_data(self, rules, dict_oval_trees, out_src):
        for rule in rules['rules']:
            try:
                self._put_to_dict_oval_trees(dict_oval_trees, rule)
                if not self.all_in_one:
                    self._build_and_save_html(
                        dict_oval_trees,
                        self._get_src_for_one_graph(rule),
                        dict(rules=[rule]),
                        out_src
                    )
                    dict_oval_trees = {}
            except NotChecked as error:
                start_red_color = '\033[91m'
                end_red_color = '\033[0m'
                print(start_red_color + str(error) + end_red_color)
        if self.all_in_one:
            self._build_and_save_html(
                dict_oval_trees, self.get_save_src(
                    'rules' + self._get_date()), rules, out_src)

    def _build_and_save_html(self, dict_oval_trees, src, rules, out_src):
        self.html_builder.save_html(dict_oval_trees, src, rules)
        out_src.append(src)

    def _get_src_for_one_graph(self, rule):
        return self.get_save_src(rule + self._get_date())

    def get_save_src(self, rule):

Missing function or method docstring

        if self.out is not None:
            os.makedirs(self.out, exist_ok=True)
            return os.path.join(
                self.out,
                self.get_start_of_file_name() + rule + '.html')
        return os.path.join(
            tempfile.gettempdir(),
            self.get_start_of_file_name() + rule + '.html')

    def open_results_in_web_browser(self, paths_to_results):

Missing function or method docstring

        if self.display_html:
            try:
                self.web_browsers.append(
                    subprocess.Popen(["firefox", *paths_to_results]))
            except subprocess.CalledProcessError:
                default_web_browser_name = webbrowser.get().name
                self.web_browsers.append(
                    subprocess.Popen([default_web_browser_name, *paths_to_results]))

    def kill_web_browsers(self):

Missing function or method docstring

        for web_browser in self.web_browsers:
            web_browser.kill()

    @staticmethod
    def arg_all_in_one(parser):

Missing function or method docstring

        parser.add_argument(
            '-i',
            '--all-in-one',
            action="store_true",
            default=False,
            help="Processes all rules into one file.")

    @staticmethod
    def arg_display(parser):

Missing function or method docstring

        parser.add_argument(
            '-d',
            '--display',
            action="store_true",
            default=False,
            help="Enables opening a web browser with a graph, when is used --output.")