sdoc.sdoc2.node.TableNode.TableNode.prepare_content_tree() - Code Metrics - SDoc/py-sdoc - Measure and Improve Code Quality continuously with Scrutinizer

TableNode.prepare_content_tree() A
last analyzed 2023-03-09 17:46 UTC

↳ Parent: sdoc.sdoc2.node.TableNode

Complexity

Conditions

Size

Total Lines	23
Code Lines	12

Duplication

Lines	23
Ratio	100 %

Code Coverage

Tests	1
CRAP Score	16.3253

Importance

Changes

Metric	Value
eloc	12
dl	23
loc	23
ccs	1
cts	12
cp	0.0833
rs	9.8
c	0
b	0
f	0
cc	4
nop	1
crap	16.3253

import csv
import io
import re
from typing import Any, Dict, List, Optional

from cleo.io.io import IO

from sdoc.sdoc2 import in_scope, out_scope
from sdoc.sdoc2.helper.Enumerable import Enumerable
from sdoc.sdoc2.node.CaptionNode import CaptionNode
from sdoc.sdoc2.node.LabelNode import LabelNode
from sdoc.sdoc2.node.Node import Node
from sdoc.sdoc2.NodeStore import NodeStore


class TableNode(Node):

    """
    SDoc2 node for table.
    """

    # ------------------------------------------------------------------------------------------------------------------
    def __init__(self, io_object: IO, options: Dict[str, str]):
        """
        Object constructor.

        :param OutputStyle io_object: The IO object.
        :param dict[str,str] options: The options of this table.
        """
        super().__init__(io_object, 'table', options)

        self.rows: List[List[str]] = []
        """
        The table rows.
        """

        self.column_headers: List[str] = []
        """
        The column headers of the table (if any).
        """

        self.alignments: List[Optional[str]] = []
        """
        The text alignments in the table columns.
        """

        self.caption: Optional[str] = None
        """
        The caption for the table.
        """

    # ------------------------------------------------------------------------------------------------------------------
    def get_command(self) -> str:
        """
        Returns the command of this node, i.e. table.
        """
        return 'table'

    # ------------------------------------------------------------------------------------------------------------------
    def is_block_command(self) -> bool:
        """
        Returns True.
        """
        return True

    # ------------------------------------------------------------------------------------------------------------------
    def is_inline_command(self) -> bool:
        """
        Returns False.
        """
        return False

    # ------------------------------------------------------------------------------------------------------------------
    def number(self, numbers: Dict[str, Any]) -> None:
        """
        Numbers all numerable nodes such as chapters, sections, figures, and, items.

        :param dict[str,any] numbers: The current numbers.
        """
        if 'table' not in numbers:
            numbers['table'] = Enumerable()
            numbers['table'].generate_numeration(1)
            numbers['table'].increment_last_level()
        else:
            numbers['table'].increment_last_level()

        self._options['number'] = numbers['table'].get_string()

        super().number(numbers)

    # ------------------------------------------------------------------------------------------------------------------
    def prepare_content_tree(self) -> None:
        """
        Prepares this node for further processing.
        """
        table_nodes = []

        for node_id in self.child_nodes:
            node = in_scope(node_id)

            if isinstance(node, LabelNode):
                self.setup_label(node)

            elif isinstance(node, CaptionNode):
                self.caption = node.argument

            else:
                table_nodes.append(node)

            node.prepare_content_tree()

            out_scope(node)

        self.generate_table(table_nodes)

    # ------------------------------------------------------------------------------------------------------------------
    def setup_label(self, node):
        """
        Sets the data of a label to current table.

        :param sdoc.sdoc2.node.LabelNode.LabelNode node: The label node.
        """
        self._options['id'] = node.argument

    # ------------------------------------------------------------------------------------------------------------------
    def generate_table(self, nodes):
        """
        Generates the table node.

        :param list[sdoc.sdoc2.node.Node.Node] nodes: The list with nodes.
        """
        table_data = TableNode.divide_text_nodes(nodes)
        split_data = TableNode.split_by_new_lines(table_data)
        rows = self.generate_output_rows(split_data)

        if self.has_header(rows):
            self.column_headers = rows[0]
            self.rows = rows[2:]
            self.alignments = self.get_column_alignments(rows[1])
        else:
            self.rows = rows

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def divide_text_nodes(nodes: List[Any]) -> List[Any]:
        """
        Divides text nodes from other type of nodes.

        :param: list[any] nodes: The list with nodes.

        :rtype: list[any]
        """
        table_data = []
        table_text_repr = ''

        for node in nodes:
            if node.get_command() == 'TEXT':
                table_text_repr += node.argument
            else:
                table_data.append(table_text_repr)
                table_data.append(node)
                table_text_repr = ''

        if table_text_repr:
            table_data.append(table_text_repr)

        return table_data

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def split_by_new_lines(table_data: List[Any]) -> List[Any]:
        """
        Splits data by newline symbols.

        :param list[any] table_data:

        :rtype: list[any]
        """
        split_data = []

        for data in table_data:
            if isinstance(data, str):
                split_data.append(data.split('\n'))
            else:
                split_data.append(data)

        for data in split_data:
            if isinstance(data, list):
                for element in data:
                    if element.isspace() or element == '':
                        data.remove(element)

        return split_data

    # ------------------------------------------------------------------------------------------------------------------
    def generate_output_rows(self, split_data: List[Any]) -> List[List[Any]]:
        """
        Generates the rows for final representation.

        :param list[any] split_data: The split data.

        :rtype: list[list[any]]
        """
        separated_data = TableNode.split_by_vertical_separators(split_data)

        rows = []

        for item in separated_data:
            row = []

            for data in item:
                if data and isinstance(data, str) and not data.isspace():
                    string = io.StringIO(data)
                    self.parse_vertical_separators(string, row)

                else:
                    if data:
                        row.append(data)

            if row:
                rows.append(row)

        return rows

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def split_by_vertical_separators(split_data: List[Any]) -> List[List[Any]]:
        """
        Splits data by vertical separators and creates rows with data.

        :param list[any] split_data: The split data.

        :rtype: list[list[any]]
        """
        rows = []
        row = []

        for item in split_data:
            # If we have a list we pass for each element.
            # In list we have only text elements.
            if isinstance(item, list):
                for element in item:

                    # If element starts with '|' we just add element to row.
                    if element.strip().startswith('|'):
                        row.append(element)

                    # If element ends with '|' we add row to rows list, reset row to empty list
                    # and append there current element. We do it because we know that if string ends with '|',
                    # after it we have non-text element.
                    elif element.strip().endswith('|'):
                        row = TableNode.reset_data(row, rows)
                        row.append(element)

                    # If we have element which not starts and not ends in '|' we do this block.
                    else:
                        # If last added element of row is not string we add row to rows list, reset row to empty.
                        if row and not isinstance(row[-1], str):
                            row = TableNode.reset_data(row, rows)
                        # And just add full element with text like a row to list of rows.
                        rows.append([element])

            # Do this block if element is not a list.
            else:
                # If last added element not ends with '|' we add row to rows list, and reset row to empty list.
                if row and not row[-1].strip().endswith('|'):
                    row = TableNode.reset_data(row, rows)
                # Add item to row.
                row.append(item)

        return rows

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def reset_data(row: List[Any], rows: List[List[any]]) -> List[Any]:
        """
        Appends row with data to list of rows, and clear row from any elements.

        Warning! This method changes original list 'rows'.

        :param list[any] row: The row with elements
        :param list[list[any]] rows: The list with many rows.
        """
        rows.append(row)
        return []

    # ------------------------------------------------------------------------------------------------------------------
    def parse_vertical_separators(self, string: io.StringIO, row: List[any]) -> None:
        """
        Splits row by vertical separator for future output.

        :param StringIO string: The string which we will separate.
        :param list[mixed] row: The list with the row in which we append data.
        """
        reader = csv.reader(string, delimiter='|')
        for line in reader:
            new_row = self.prune_whitespace(line)

            for item in new_row:
                if item:
                    row.append(item)

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def has_header(rows: List[str]) -> bool:
        """
        Returns True if the table has a table header.

        :param list[str] rows: The second row of the table.
        """
        is_header = True

        if len(rows) == 1:
            return False

        for align in rows[1]:
            header_part = re.findall(':?---+-*:?', align)
            if not header_part:
                is_header = False
                break

        return is_header

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def get_column_alignments(row: List[str]) -> List[str]:
        """
        Sets alignments on table columns.

        :param list[str] row: The row with hyphens for creating column headers.
        """
        alignments = []
        for hyphens in row:
            hyphens = hyphens.strip()
            if hyphens.startswith(':') and hyphens.endswith(':'):
                alignments.append('center')
            elif hyphens.startswith(':'):
                alignments.append('left')
            elif hyphens.endswith(':'):
                alignments.append('right')
            else:
                alignments.append('')

        return alignments

    # ------------------------------------------------------------------------------------------------------------------
    @staticmethod
    def prune_whitespace(row: List[str]) -> List[str]:
        """
        Strips whitespaces from the text of an each cell.

        :param list[str] row: The row with text of an each cell.
        """
        clear_row = []
        for item in row:
            clear_text = item.strip()
            clear_text = re.sub(r'\s+', ' ', clear_text)
            clear_row.append(clear_text)

        return clear_row


# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('table', TableNode)


1	1		import csv
2	1		import io
3	1		import re
4	1		from typing import Any, Dict, List, Optional
5
6	1		from cleo.io.io import IO
7
8	1		from sdoc.sdoc2 import in_scope, out_scope
9	1		from sdoc.sdoc2.helper.Enumerable import Enumerable
10	1		from sdoc.sdoc2.node.CaptionNode import CaptionNode
11	1		from sdoc.sdoc2.node.LabelNode import LabelNode
12	1		from sdoc.sdoc2.node.Node import Node
13	1		from sdoc.sdoc2.NodeStore import NodeStore
14
15
16	1	View Code Duplication	class TableNode(Node):
			0 ignored issues – show Duplication introduced 2020-12-05 07:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
17			"""
18			SDoc2 node for table.
19			"""
20
21			# ------------------------------------------------------------------------------------------------------------------
22	1		def __init__(self, io_object: IO, options: Dict[str, str]):
23			"""
24			Object constructor.
25
26			:param OutputStyle io_object: The IO object.
27			:param dict[str,str] options: The options of this table.
28			"""
29			super().__init__(io_object, 'table', options)
30
31			self.rows: List[List[str]] = []
32			"""
33			The table rows.
34			"""
35
36			self.column_headers: List[str] = []
37			"""
38			The column headers of the table (if any).
39			"""
40
41			self.alignments: List[Optional[str]] = []
42			"""
43			The text alignments in the table columns.
44			"""
45
46			self.caption: Optional[str] = None
47			"""
48			The caption for the table.
49			"""
50
51			# ------------------------------------------------------------------------------------------------------------------
52	1		def get_command(self) -> str:
53			"""
54			Returns the command of this node, i.e. table.
55			"""
56			return 'table'
57
58			# ------------------------------------------------------------------------------------------------------------------
59	1		def is_block_command(self) -> bool:
60			"""
61			Returns True.
62			"""
63			return True
64
65			# ------------------------------------------------------------------------------------------------------------------
66	1		def is_inline_command(self) -> bool:
67			"""
68			Returns False.
69			"""
70			return False
71
72			# ------------------------------------------------------------------------------------------------------------------
73	1		def number(self, numbers: Dict[str, Any]) -> None:
74			"""
75			Numbers all numerable nodes such as chapters, sections, figures, and, items.
76
77			:param dict[str,any] numbers: The current numbers.
78			"""
79			if 'table' not in numbers:
80			numbers['table'] = Enumerable()
81			numbers['table'].generate_numeration(1)
82			numbers['table'].increment_last_level()
83			else:
84			numbers['table'].increment_last_level()
85
86			self._options['number'] = numbers['table'].get_string()
87
88			super().number(numbers)
89
90			# ------------------------------------------------------------------------------------------------------------------
91	1		def prepare_content_tree(self) -> None:
92			"""
93			Prepares this node for further processing.
94			"""
95			table_nodes = []
96
97			for node_id in self.child_nodes:
98			node = in_scope(node_id)
99
100			if isinstance(node, LabelNode):
101			self.setup_label(node)
102
103			elif isinstance(node, CaptionNode):
104			self.caption = node.argument
105
106			else:
107			table_nodes.append(node)
108
109			node.prepare_content_tree()
110
111			out_scope(node)
112
113			self.generate_table(table_nodes)
114
115			# ------------------------------------------------------------------------------------------------------------------
116	1		def setup_label(self, node):
117			"""
118			Sets the data of a label to current table.
119
120			:param sdoc.sdoc2.node.LabelNode.LabelNode node: The label node.
121			"""
122			self._options['id'] = node.argument
123
124			# ------------------------------------------------------------------------------------------------------------------
125	1		def generate_table(self, nodes):
126			"""
127			Generates the table node.
128
129			:param list[sdoc.sdoc2.node.Node.Node] nodes: The list with nodes.
130			"""
131			table_data = TableNode.divide_text_nodes(nodes)
132			split_data = TableNode.split_by_new_lines(table_data)
133			rows = self.generate_output_rows(split_data)
134
135			if self.has_header(rows):
136			self.column_headers = rows[0]
137			self.rows = rows[2:]
138			self.alignments = self.get_column_alignments(rows[1])
139			else:
140			self.rows = rows
141
142			# ------------------------------------------------------------------------------------------------------------------
143	1		@staticmethod
144	1		def divide_text_nodes(nodes: List[Any]) -> List[Any]:
145			"""
146			Divides text nodes from other type of nodes.
147
148			:param: list[any] nodes: The list with nodes.
149
150			:rtype: list[any]
151			"""
152			table_data = []
153			table_text_repr = ''
154
155			for node in nodes:
156			if node.get_command() == 'TEXT':
157			table_text_repr += node.argument
158			else:
159			table_data.append(table_text_repr)
160			table_data.append(node)
161			table_text_repr = ''
162
163			if table_text_repr:
164			table_data.append(table_text_repr)
165
166			return table_data
167
168			# ------------------------------------------------------------------------------------------------------------------
169	1		@staticmethod
170	1		def split_by_new_lines(table_data: List[Any]) -> List[Any]:
171			"""
172			Splits data by newline symbols.
173
174			:param list[any] table_data:
175
176			:rtype: list[any]
177			"""
178			split_data = []
179
180			for data in table_data:
181			if isinstance(data, str):
182			split_data.append(data.split('\n'))
183			else:
184			split_data.append(data)
185
186			for data in split_data:
187			if isinstance(data, list):
188			for element in data:
189			if element.isspace() or element == '':
190			data.remove(element)
191
192			return split_data
193
194			# ------------------------------------------------------------------------------------------------------------------
195	1		def generate_output_rows(self, split_data: List[Any]) -> List[List[Any]]:
196			"""
197			Generates the rows for final representation.
198
199			:param list[any] split_data: The split data.
200
201			:rtype: list[list[any]]
202			"""
203			separated_data = TableNode.split_by_vertical_separators(split_data)
204
205			rows = []
206
207			for item in separated_data:
208			row = []
209
210			for data in item:
211			if data and isinstance(data, str) and not data.isspace():
212			string = io.StringIO(data)
213			self.parse_vertical_separators(string, row)
214
215			else:
216			if data:
217			row.append(data)
218
219			if row:
220			rows.append(row)
221
222			return rows
223
224			# ------------------------------------------------------------------------------------------------------------------
225	1		@staticmethod
226	1		def split_by_vertical_separators(split_data: List[Any]) -> List[List[Any]]:
227			"""
228			Splits data by vertical separators and creates rows with data.
229
230			:param list[any] split_data: The split data.
231
232			:rtype: list[list[any]]
233			"""
234			rows = []
235			row = []
236
237			for item in split_data:
238			# If we have a list we pass for each element.
239			# In list we have only text elements.
240			if isinstance(item, list):
241			for element in item:
242
243			# If element starts with '\|' we just add element to row.
244			if element.strip().startswith('\|'):
245			row.append(element)
246
247			# If element ends with '\|' we add row to rows list, reset row to empty list
248			# and append there current element. We do it because we know that if string ends with '\|',
249			# after it we have non-text element.
250			elif element.strip().endswith('\|'):
251			row = TableNode.reset_data(row, rows)
252			row.append(element)
253
254			# If we have element which not starts and not ends in '\|' we do this block.
255			else:
256			# If last added element of row is not string we add row to rows list, reset row to empty.
257			if row and not isinstance(row[-1], str):
258			row = TableNode.reset_data(row, rows)
259			# And just add full element with text like a row to list of rows.
260			rows.append([element])
261
262			# Do this block if element is not a list.
263			else:
264			# If last added element not ends with '\|' we add row to rows list, and reset row to empty list.
265			if row and not row[-1].strip().endswith('\|'):
266			row = TableNode.reset_data(row, rows)
267			# Add item to row.
268			row.append(item)
269
270			return rows
271
272			# ------------------------------------------------------------------------------------------------------------------
273	1		@staticmethod
274	1		def reset_data(row: List[Any], rows: List[List[any]]) -> List[Any]:
275			"""
276			Appends row with data to list of rows, and clear row from any elements.
277
278			Warning! This method changes original list 'rows'.
279
280			:param list[any] row: The row with elements
281			:param list[list[any]] rows: The list with many rows.
282			"""
283			rows.append(row)
284			return []
285
286			# ------------------------------------------------------------------------------------------------------------------
287	1		def parse_vertical_separators(self, string: io.StringIO, row: List[any]) -> None:
288			"""
289			Splits row by vertical separator for future output.
290
291			:param StringIO string: The string which we will separate.
292			:param list[mixed] row: The list with the row in which we append data.
293			"""
294			reader = csv.reader(string, delimiter='\|')
295			for line in reader:
296			new_row = self.prune_whitespace(line)
297
298			for item in new_row:
299			if item:
300			row.append(item)
301
302			# ------------------------------------------------------------------------------------------------------------------
303	1		@staticmethod
304	1		def has_header(rows: List[str]) -> bool:
305			"""
306			Returns True if the table has a table header.
307
308			:param list[str] rows: The second row of the table.
309			"""
310			is_header = True
311
312			if len(rows) == 1:
313			return False
314
315			for align in rows[1]:
316			header_part = re.findall(':?---+-*:?', align)
317			if not header_part:
318			is_header = False
319			break
320
321			return is_header
322
323			# ------------------------------------------------------------------------------------------------------------------
324	1		@staticmethod
325	1		def get_column_alignments(row: List[str]) -> List[str]:
326			"""
327			Sets alignments on table columns.
328
329			:param list[str] row: The row with hyphens for creating column headers.
330			"""
331			alignments = []
332			for hyphens in row:
333			hyphens = hyphens.strip()
334			if hyphens.startswith(':') and hyphens.endswith(':'):
335			alignments.append('center')
336			elif hyphens.startswith(':'):
337			alignments.append('left')
338			elif hyphens.endswith(':'):
339			alignments.append('right')
340			else:
341			alignments.append('')
342
343			return alignments
344
345			# ------------------------------------------------------------------------------------------------------------------
346	1		@staticmethod
347	1		def prune_whitespace(row: List[str]) -> List[str]:
348			"""
349			Strips whitespaces from the text of an each cell.
350
351			:param list[str] row: The row with text of an each cell.
352			"""
353			clear_row = []
354			for item in row:
355			clear_text = item.strip()
356			clear_text = re.sub(r'\s+', ' ', clear_text)
357			clear_row.append(clear_text)
358
359			return clear_row
360
361
362			# ----------------------------------------------------------------------------------------------------------------------
363			NodeStore.register_block_command('table', TableNode)
364

SDoc / py-sdoc

TableNode.prepare_content_tree() A last analyzed 2023-03-09 17:46 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

TableNode.prepare_content_tree() A
last analyzed 2023-03-09 17:46 UTC