15240022402

Committed 25 May 2025 04:53PM UTC coverage: 83.884% (+0.4%) from 83.446%

Build # 15240022402

Build Type

push

github

Committed by

rjfarmer

Commit Message

Test for parameter values

Run Details

11 of 20 new or added lines in 2 files covered. (55.0%)

635 of 757 relevant lines covered (83.88%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.32

/gfModParser/modules/symbols.py

# SPDX-License-Identifier: GPL-2.0+
import re

from .. import utils
from . import properties


class Symbols:
    """
    Holds all variables/procedures/arguments in module
    """

    def __init__(self, symbols, *, version):
        self._raw = symbols
        self.version = version
        self.symbols = symbols
        self._split = None

    def __contains__(self, key):
        if self._split is None:
            self._split_symbols()
        return key in self._split

    def __getitem__(self, key):
        if self._split is None:
            self._split_symbols()

        return self._split[key]

    def _split_symbols(self):

        # Remove initial '(' and final ')\n')
        self.symbols = self.symbols[1:-2]

        # Remove line breaks
        self.symbols = self.symbols.replace("\n", " ")

        # Split data up into groups
        # intrinsic procedures, have brackets in their module name
        matches = re.split(r"(\d+ '\w*' '[\(\)\w]*' '\w*' \d+ )", self.symbols)

        self._split = {}
        # Ignore first match which is empty and take
        # pairs of elements as we get (id,data) from the regex
        for i in range(1, len(matches), 2):
            id = int(matches[i].split(" ")[0].strip())
            data = matches[i] + matches[i + 1]
            # Remove starting \n and ending
            self._split[id] = Symbol(id, data[1:], version=self.version)

    def keys(self):
        if self._split is None:
            self._split_symbols()

        return self._split.keys()

    def items(self):
        if self._split is None:
            self._split_symbols()

        return self._split.items()

    def values(self):
        if self._split is None:
            self._split_symbols()

        return self._split.values()


class Symbol:
    """
    Single object (variable, procedure, argument etc)
    """

    def __init__(self, id, symbol, *, version):
        self.version = version
        self._id = id
        # For very long variable names we may get 'name'\n'module'
        # So replace any \n we find before we get to the first ((
        # dont use single ( as intrinsics use that in their module name
        self._raw = symbol

        self._symbol = symbol.split(" ", maxsplit=5)

    @property
    def mangled_name(self):
        if not self.bind_c:
            return f"__{self.module}_MOD_{self.name}"
        else:
            return utils.string_clean(self._symbol[3])

    @property
    def id(self):
        return int(self._id)

    @property
    def name(self):
        return utils.string_clean(self._symbol[1])

    @property
    def module(self):
        return utils.string_clean(self._symbol[2])

    @property
    def bind_c(self):
        return len(utils.string_clean(self._symbol[3])) > 0

    @property
    def parent_id(self):
        return int(self._symbol[4])

    @property
    def properties(self):
        return properties.Properties(self._symbol[5], version=self.version)

    def __str__(self):
        return self.name

    def __repr__(self):
        return self.name

1	# SPDX-License-Identifier: GPL-2.0+
2	import re	1✔
3
4	from .. import utils	1✔
5	from . import properties	1✔
6
7
8	class Symbols:	1✔
9	"""
10	Holds all variables/procedures/arguments in module
11	"""
12
13	def __init__(self, symbols, *, version):	1✔
14	self._raw = symbols	1✔
15	self.version = version	1✔
16	self.symbols = symbols	1✔
17	self._split = None	1✔
18
19	def __contains__(self, key):	1✔
20	if self._split is None:	1✔
21	self._split_symbols()	1✔
22	return key in self._split	1✔
23
24	def __getitem__(self, key):	1✔
25	if self._split is None:	1✔
26	self._split_symbols()	1✔
27
28	return self._split[key]	1✔
29
30	def _split_symbols(self):	1✔
31
32	# Remove initial '(' and final ')\n')
33	self.symbols = self.symbols[1:-2]	1✔
34
35	# Remove line breaks
36	self.symbols = self.symbols.replace("\n", " ")	1✔
37
38	# Split data up into groups
39	# intrinsic procedures, have brackets in their module name
40	matches = re.split(r"(\d+ '\w' '[\(\)\w]' '\w*' \d+ )", self.symbols)	1✔
41
42	self._split = {}	1✔
43	# Ignore first match which is empty and take
44	# pairs of elements as we get (id,data) from the regex
45	for i in range(1, len(matches), 2):	1✔
46	id = int(matches[i].split(" ")[0].strip())	1✔
47	data = matches[i] + matches[i + 1]	1✔
48	# Remove starting \n and ending
49	self._split[id] = Symbol(id, data[1:], version=self.version)	1✔
50
51	def keys(self):	1✔
NEW 52	if self._split is None:	×
NEW 53	self._split_symbols()	×
54
NEW 55	return self._split.keys()	×
56
57	def items(self):	1✔
NEW 58	if self._split is None:	×
NEW 59	self._split_symbols()	×
60
NEW 61	return self._split.items()	×
62
63	def values(self):	1✔
NEW 64	if self._split is None:	×
NEW 65	self._split_symbols()	×
66
NEW 67	return self._split.values()	×
68
69
70	class Symbol:	1✔
71	"""
72	Single object (variable, procedure, argument etc)
73	"""
74
75	def __init__(self, id, symbol, *, version):	1✔
76	self.version = version	1✔
77	self._id = id	1✔
78	# For very long variable names we may get 'name'\n'module'
79	# So replace any \n we find before we get to the first ((
80	# dont use single ( as intrinsics use that in their module name
81	self._raw = symbol	1✔
82
83	self._symbol = symbol.split(" ", maxsplit=5)	1✔
84
85	@property	1✔
86	def mangled_name(self):	1✔
87	if not self.bind_c:	1✔
88	return f"__{self.module}_MOD_{self.name}"	1✔
89	else:
90	return utils.string_clean(self._symbol[3])	1✔
91
92	@property	1✔
93	def id(self):	1✔
94	return int(self._id)	1✔
95
96	@property	1✔
97	def name(self):	1✔
98	return utils.string_clean(self._symbol[1])	1✔
99
100	@property	1✔
101	def module(self):	1✔
102	return utils.string_clean(self._symbol[2])	1✔
103
104	@property	1✔
105	def bind_c(self):	1✔
106	return len(utils.string_clean(self._symbol[3])) > 0	1✔
107
108	@property	1✔
109	def parent_id(self):	1✔
110	return int(self._symbol[4])	1✔
111
112	@property	1✔
113	def properties(self):	1✔
114	return properties.Properties(self._symbol[5], version=self.version)	1✔
115
116	def __str__(self):	1✔
117	return self.name	1✔
118
119	def __repr__(self):	1✔
120	return self.name	1✔

rjfarmer / gfModParser / 15240022402

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous