Passed
Push — master ( fbcbb8...bf605d )
by Matěj
03:39 queued 11s
created

oval_graph._builder_oval_graph   A

Complexity

Total Complexity 8

Size/Duplication

Total Lines 61
Duplicated Lines 0 %

Test Coverage

Coverage 91.3%

Importance

Changes 0
Metric Value
eloc 48
dl 0
loc 61
ccs 21
cts 23
cp 0.913
rs 10
c 0
b 0
f 0
wmc 8

3 Methods

Rating   Name   Duplication   Size   Complexity  
A _BuilderOvalGraph.__init__() 0 2 1
B _BuilderOvalGraph._definition_dict_to_node() 0 34 6
A _BuilderOvalGraph.get_oval_graph_from_dict_of_rule() 0 13 1
1 1
import uuid
2
3 1
from .oval_node import OvalNode
4
5
# rework this (use static metodes)
6
7
8 1
class _BuilderOvalGraph:
9 1
    def __init__(self):
10 1
        pass
11
12 1
    def _definition_dict_to_node(self, dict_of_definition):
13 1
        children = []
14 1
        for child in dict_of_definition['node']:
15 1
            if 'operator' in child and 'id':
16 1
                children.append(self._definition_dict_to_node(child))
17
            else:
18 1
                children.append(
19
                    OvalNode(
20
                        node_id=child['value_id'],
21
                        node_type='value',
22
                        value=child['value'],
23
                        negation=child['negate'],
24
                        comment=child['comment'],
25
                        tag=child['tag'],
26
                        test_result_details=child['test_result_details'],
27
                    ))
28
29 1
        if 'id' in dict_of_definition:
30
            children[0].node_id = dict_of_definition['id']
31
            return children[0]
32
        else:
33 1
            node_id = None
34 1
            if 'definition_id' in dict_of_definition:
35 1
                node_id = dict_of_definition['definition_id']
36
            else:
37 1
                node_id = str(uuid.uuid4())
38 1
            return OvalNode(
39
                node_id=node_id,
40
                node_type='operator',
41
                value=dict_of_definition['operator'],
42
                negation=dict_of_definition['negate'],
43
                comment=dict_of_definition['comment'],
44
                tag=dict_of_definition['tag'],
45
                children=children,
46
            )
47
48 1
    def get_oval_graph_from_dict_of_rule(self, rule):
49 1
        dict_of_definition = rule['definition']
50 1
        dict_of_definition['node']['definition_id'] = rule['definition_id']
51 1
        return OvalNode(
52
            node_id=rule['rule_id'],
53
            node_type='operator',
54
            value='and',
55
            negation=False,
56
            comment=dict_of_definition['comment'],
57
            tag="Rule",
58
            children=[
59
                self._definition_dict_to_node(
60
                    dict_of_definition['node'])],
61
        )
62