oval_graph.command_line_client.client_html_output

Complexity

Total Complexity

20

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Test Coverage

Coverage

88.14%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	ClientHtmlOutput._build_and_save_html()	0	3	1
A	ClientHtmlOutput.prepare_args_when_output_is_html()	0	13	1
A	ClientHtmlOutput._prepare_data()	0	16	5
A	ClientHtmlOutput.get_src()	0	3	1
A	ClientHtmlOutput.__init__()	0	9	3
A	ClientHtmlOutput.open_web_browser()	0	6	3
A	ClientHtmlOutput.get_save_src()	0	9	2
A	ClientHtmlOutput.open_html()	0	3	2
A	ClientHtmlOutput.print_red_text()	0	4	1
A	ClientHtmlOutput.prepare_data()	0	6	1

import webbrowser
import os
import tempfile

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


class ClientHtmlOutput(Client):
    def __init__(self, args):
        super().__init__(args)
        self.parts = self.get_src('../parts')
        self.START_OF_FILE_NAME = 'graph-of-'

        self.all_in_one = self.arg.all_in_one
        self.all_rules = True if self.all_in_one else self.arg.all
        self.display_html = True if self.out is None else self.arg.display
        self.html_builder = BuilderHtmlGraph(self.parts, self.verbose)

    def print_red_text(self, text):
        CRED = '\033[91m'
        CEND = '\033[0m'
        print(CRED + str(text) + CEND)

    def get_src(self, src):
        _dir = os.path.dirname(os.path.realpath(__file__))
        return str(os.path.join(_dir, src))

    def prepare_data(self, rules):
        out_src = []
        oval_tree_dict = dict()
        self._prepare_data(rules, oval_tree_dict, out_src)
        self.open_html(out_src)
        return out_src

    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:
                self.print_red_text(error)
        if self.all_in_one:
            self._build_and_save_html(
                dict_oval_trees, self.get_save_src(
                    'rules' + self.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_save_src(self, rule):
        if self.out is not None:
            os.makedirs(self.out, exist_ok=True)
            return os.path.join(
                self.out,
                self.START_OF_FILE_NAME + rule + '.html')
        return os.path.join(
            tempfile.gettempdir(),
            self.START_OF_FILE_NAME + rule + '.html')

    def open_html(self, out):
        for src in out:
            self.open_web_browser(src)

    def open_web_browser(self, src):
        if self.display_html:
            try:
                webbrowser.get('firefox').open_new_tab(src)
            except BaseException:
                webbrowser.open_new_tab(src)

    def prepare_args_when_output_is_html(self):
        self.parser.add_argument(
            '-i',
            '--all-in-one',
            action="store_true",
            default=False,
            help="Processes all rules into one file.")
        self.parser.add_argument(
            '-d',
            '--display',
            action="store_true",
            default=False,
            help="Enables opening a web browser with a graph, when is used --output.")