merge
This commit is contained in:
commit
bcfb07e5c3
|
|
@ -1,7 +1,7 @@
|
|||
pyyaml==6.0
|
||||
rich~=11.0.0
|
||||
regex~=2022.1.18
|
||||
rich==12.0.1
|
||||
regex==2022.3.15
|
||||
pyparse~=1.1.7
|
||||
pyparsing[diagrams]~=3.0.7
|
||||
|
||||
pytest~=6.2.5
|
||||
pytest==7.1.1
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
flake8==4.0.1
|
||||
tox==3.24.3
|
||||
pytest==6.2.5
|
||||
pytest-cov==2.12.1
|
||||
mypy===0.910
|
||||
tox==3.24.5
|
||||
pytest==7.1.1
|
||||
pytest-cov==3.0.0
|
||||
mypy==0.941
|
||||
pyyaml==6.0
|
||||
rich~=11.0.0
|
||||
regex~=2022.1.18
|
||||
rich==12.0.1
|
||||
regex==2022.3.15
|
||||
|
|
|
|||
|
|
@ -1 +1,18 @@
|
|||
# Interprets where the parser is located and resolves errors
|
||||
class BaseContainer:
|
||||
pass
|
||||
# Must define __init__, __str__, __repr__ and a print_all method
|
||||
# will contain all sub-tokens and/or sub-containers
|
||||
# Defines a method to get all token elements (__iter__) and a method to get a specific element (__getitem__)
|
||||
# Defines a method to get the number of elements (__len__)
|
||||
# Defines a method to get the name of the container (__name__)
|
||||
# Defines a method to the optionals inside the container ( ? .optional())
|
||||
|
||||
# Define containers all the Enhanced text elements, divs, headers, list and any element that can be a container
|
||||
|
||||
|
||||
class ContextManager:
|
||||
pass
|
||||
# Defines all methods to manage the context of the parser as a file is being parsed
|
||||
# Builds all containers as the parser is parsing the file
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ class SemanticType:
|
|||
for elt in self.content:
|
||||
try:
|
||||
return_list.append(elt.to_markup())
|
||||
except Exception:
|
||||
except Exception: # noqa E722 (This function is used for testing only)
|
||||
return_list.append(str(elt))
|
||||
return f"<{self.label} = '{','.join(return_list)}' />"
|
||||
return f'<[NOC] {self.label} />'
|
||||
|
|
@ -212,8 +212,8 @@ def reparse(parse_element):
|
|||
:param parse_element: pp object defining desired match
|
||||
:return: returns a function parsing given match with specified parsing element
|
||||
"""
|
||||
def _reparse(original_string, _, __):
|
||||
parse_element.parse_string(original_string)
|
||||
def _reparse(__, _, tokens):
|
||||
return parse_element.parseString(tokens[0]) # TODO: fix this with a proper solution
|
||||
|
||||
return _reparse
|
||||
|
||||
|
|
@ -232,7 +232,7 @@ def readable_markup(list_of_tokens):
|
|||
else:
|
||||
try:
|
||||
readable_list.append(token.to_markup())
|
||||
except Exception:
|
||||
except Exception: # noqa E722 (This function is used for testing and readability purposes)
|
||||
readable_list.append(str(token))
|
||||
return " ".join(readable_list)
|
||||
|
||||
|
|
@ -243,7 +243,7 @@ value = (pps(quotes) + pp.Word(pp.alphanums + r'.') + pps(pp.match_previous_lite
|
|||
pp.common.fnumber)("value")
|
||||
assignation = pp.Group(
|
||||
pp.common.identifier('var_name') + pps('=') + value('var_value')
|
||||
)("assignation") # TODO: More extensive testing
|
||||
)("assignation")
|
||||
text = pp.OneOrMore(pp.Word(pp.alphanums))('text').add_parse_action(of_type(TextToken))
|
||||
url_characters = pp.common.url
|
||||
|
||||
|
|
@ -251,20 +251,20 @@ url_characters = pp.common.url
|
|||
var = pps('[') + pp.delimitedList(
|
||||
assignation.add_parse_action(of_type(BeAssignToken)) ^
|
||||
value.add_parse_action(of_type(BeValueToken))
|
||||
)("list_vars").set_name("list_vars") + pps(']') # TODO: More extensive testing
|
||||
)("list_vars").set_name("list_vars") + pps(']')
|
||||
|
||||
# Specific elements
|
||||
image_element = ('@{' + pp.common.identifier('image_name') + '}')("image_element")
|
||||
alias_element = ('@[' + pp.common.identifier('alias_name') + ']')("alias_element")
|
||||
expression = pp.Word(pp.alphanums + r'=+-_\'",;:!\/\\ ')
|
||||
html_insert = pps('{') + expression('html_insert') + pps('}') # TODO: More extensive testing
|
||||
class_insert = pps('{{') + expression('class_insert') + pps('}}') # TODO: test dis
|
||||
expression = pp.Word(pp.alphanums + r'=+-_\'",;:!\/\\. ')
|
||||
html_insert = pps('{') + expression('html_insert') + pps('}')
|
||||
class_insert = pps('{{') + expression('class_insert') + pps('}}')
|
||||
|
||||
# Optional elements
|
||||
optional = (
|
||||
pp.Opt(class_insert)("class_insert").add_parse_action(of_type(OptionalClassToken)) &
|
||||
pp.Opt(html_insert)("html_insert").add_parse_action(of_type(OptionalInsertToken)) &
|
||||
pp.Opt(var)("var").add_parse_action(of_type(OptionalVarToken)) # noqa TODO: add class_insert to tests
|
||||
optional = pp.OneOrMore(
|
||||
class_insert("class_insert").add_parse_action(of_type(OptionalClassToken)) ^
|
||||
html_insert("html_insert").add_parse_action(of_type(OptionalInsertToken)) ^
|
||||
var("var").add_parse_action(of_type(OptionalVarToken))
|
||||
)("optional").add_parse_action(of_type(OptionalToken)) # Macro OptionalToken
|
||||
|
||||
# Structural elements
|
||||
|
|
@ -279,7 +279,7 @@ display_element = pp.Word('!')
|
|||
|
||||
# Inline elements
|
||||
il_link = pp.Regex(
|
||||
r"""\[(?P<text>.+)\]\(['"](?P<url>[a-zA-Z-_:\/=@#!%\?\d\(\)\.]+)['"]\)"""
|
||||
r"""\[(?P<text>.+)\]\(['"]?(?P<url>[a-zA-Z-_:\/=@#!%\?\d\(\)\.]+)['"]?\)"""
|
||||
).add_parse_action(of_type(HyperlinkToken))
|
||||
|
||||
# Enhanced text elements
|
||||
|
|
@ -299,7 +299,7 @@ enhanced_text = pp.ZeroOrMore(
|
|||
|
||||
# Multiline elements
|
||||
se_start = (pps('<<') + structural_elements).add_parse_action(of_type(StructuralElementStartToken))
|
||||
se_end = (structural_elements + pps('>>')).add_parse_action(of_type(StructuralElementEndToken)) + optional
|
||||
se_end = (structural_elements + pps('>>')).add_parse_action(of_type(StructuralElementEndToken)) + pp.Opt(optional)
|
||||
se = se_end | se_start # Structural element
|
||||
table_row = pp.OneOrMore(
|
||||
# pp.Regex(r'\|(\d)?')('table_colspan') +
|
||||
|
|
@ -322,24 +322,30 @@ multi_line = se | table | quotation
|
|||
|
||||
# Oneline elements
|
||||
one_header = (
|
||||
header_element + pp.SkipTo(pp.match_previous_literal(header_element))
|
||||
header_element +
|
||||
pp.SkipTo(pp.match_previous_literal(header_element)) +
|
||||
pps(pp.match_previous_literal(header_element)) +
|
||||
pp.Opt(optional)
|
||||
).add_parse_action(of_type(HeaderToken))
|
||||
one_display = (
|
||||
display_element + pp.SkipTo(pp.match_previous_literal(display_element))
|
||||
display_element +
|
||||
pp.SkipTo(pp.match_previous_literal(display_element)) +
|
||||
pps(pp.match_previous_literal(display_element)) +
|
||||
pp.Opt(optional)
|
||||
).add_parse_action(of_type(DisplayToken))
|
||||
one_olist = pp.line_start + (
|
||||
pps(pp.Literal('#.')) + (
|
||||
(pp.SkipTo(optional)('text').add_parse_action(of_type(TextToken)) + optional) ^ # TODO: add reparse
|
||||
(pp.SkipTo(optional)('text').add_parse_action(reparse(enhanced_text)) + optional) |
|
||||
enhanced_text)
|
||||
).add_parse_action(of_type(EtOlistToken))
|
||||
one_ulist = pp.line_start + (
|
||||
pps(pp.Literal('-')) + (
|
||||
(pp.SkipTo(optional)('text').add_parse_action(of_type(TextToken)) + optional) ^ # TODO: add reparse
|
||||
(pp.SkipTo(optional)('text').add_parse_action(reparse(enhanced_text)) + optional) |
|
||||
enhanced_text)
|
||||
).add_parse_action(of_type(EtUlistToken))
|
||||
|
||||
# one_line sums up all one-line elements
|
||||
one_line = (one_header | one_display | one_olist | one_ulist) + pp.Opt(optional)
|
||||
one_line = (one_header | one_display | one_olist | one_ulist)
|
||||
|
||||
# Final elements
|
||||
line = one_line | multi_line | enhanced_text
|
||||
|
|
@ -350,8 +356,8 @@ line = one_line | multi_line | enhanced_text
|
|||
##############################################################################
|
||||
|
||||
# Composite elements
|
||||
image = image_element + optional
|
||||
alias = alias_element + optional
|
||||
image = image_element + pp.Opt(optional)
|
||||
alias = alias_element + pp.Opt(optional)
|
||||
|
||||
# Syntax elements
|
||||
line_to_replace = pp.OneOrMore(
|
||||
|
|
@ -371,4 +377,4 @@ if __name__ == '__main__': # pragma: no cover
|
|||
line.create_diagram("../../../dev_outputs/diagram_line.html")
|
||||
multi_line.create_diagram("../../../dev_outputs/diagram_multi_line.html")
|
||||
one_line.create_diagram("../../../dev_outputs/diagram_one_line.html")
|
||||
enhanced_text.create_diagram("../../../dev_outputs/diagram_enchanced_text.html")
|
||||
enhanced_text.create_diagram("../../../dev_outputs/diagram_enhanced_text.html")
|
||||
|
|
|
|||
|
|
@ -2,19 +2,33 @@ from itertools import zip_longest
|
|||
|
||||
import pyparsing
|
||||
import pytest
|
||||
import inspect
|
||||
|
||||
|
||||
import bootstraparse.modules.syntax as sy
|
||||
|
||||
from tools import __GL, __module_path, find_variables_in_file # , find_functions_in_file, find_classes_in_file
|
||||
|
||||
ptp = pytest.param
|
||||
__XF = pytest.mark.xfail
|
||||
|
||||
|
||||
# Cursed frame inspection
|
||||
def __GL():
|
||||
return inspect.getframeinfo(inspect.currentframe().f_back).lineno
|
||||
##############################################################################################################
|
||||
# Utility functions
|
||||
##############################################################################################################
|
||||
def likely_definition(list_expression, file):
|
||||
"""
|
||||
Returns a dict for each expression and the associated line where this expression is likely to be defined.
|
||||
:param list_expression: list of expressions
|
||||
:param file: file to search in
|
||||
:return: dict of expression and line
|
||||
"""
|
||||
likely_definition_dict = {}
|
||||
loop_list = [e for e in list_expression]
|
||||
with open(file) as f:
|
||||
for line_number, line in enumerate(f):
|
||||
for expression_id, expression in enumerate(loop_list):
|
||||
if expression in line:
|
||||
likely_definition_dict[expression] = line_number+1
|
||||
loop_list.remove(expression)
|
||||
return likely_definition_dict, file
|
||||
|
||||
|
||||
##############################################################################################################
|
||||
|
|
@ -39,6 +53,7 @@ list_of_token_types = {
|
|||
}
|
||||
|
||||
# Dictionary of all lexical elements and a list of matching strings for the Pre_parser
|
||||
# test_expression_matching
|
||||
expressions_to_match = {
|
||||
# Base elements
|
||||
"quotes": ["'hi, there'", "'hi, there'"],
|
||||
|
|
@ -59,7 +74,16 @@ expressions_to_match = {
|
|||
"html_insert": ['{test=12, 22=3, "=5}', "{testing=12, 22=3, 4=5, 6='7'}"],
|
||||
|
||||
# Optional elements
|
||||
"optional": ["a=1", "a=1.33", "tr2='hu'"],
|
||||
"optional": ["[a=1]", "[a=1, b=2]",
|
||||
"{a=1'\";}",
|
||||
"[a=1, b='2', 43, 'eee']",
|
||||
"[a=1, b='2', 43, 'eee'] {azer=,;}",
|
||||
"{{a=1, b='2', 43, 'eee'}}",
|
||||
"{{a=1, b='2', 43, 'eee'}} {azer=,;}",
|
||||
"{{a=1, b='2', 43, 'eee'}} {azer=,;} [azer=,;]",
|
||||
"[a=1, b='2', 43, 'eee'] {azer=,;} {{azer=,;}}",
|
||||
],
|
||||
|
||||
|
||||
# Pre_parser elements
|
||||
"image": ["@{image}{test=22}[a=12,22,c,d,ERE,r,3]", "@{image123_456}{a=12,22,c,d,ERE,r,3}",
|
||||
|
|
@ -110,8 +134,117 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
("[text_link]('text://www.website.com/link.html')",
|
||||
[sy.HyperlinkToken(["[text_link]('text://www.website.com/link.html')"])], __GL())
|
||||
],
|
||||
|
||||
# il_link | et_strong | et_em | et_strikethrough | et_underline | et_custom_span
|
||||
"assignation": [
|
||||
# Single assignation element, should only match the first "a=1"
|
||||
("a=1", [sy.BeAssignToken([["a", 1]]), ], __GL()),
|
||||
("a='str'", [sy.BeAssignToken([["a", 'str']]), ], __GL()),
|
||||
],
|
||||
"var": [
|
||||
# List of variables or assignations, should match "[a=12, b=13, 'c']"
|
||||
("[a=12, b=13, 'c']", [
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
sy.BeAssignToken([["b", 13]]),
|
||||
sy.BeValueToken(["c"]),
|
||||
], __GL()),
|
||||
("[a=12, b=13, 'c', d=14]", [
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
sy.BeAssignToken([["b", 13]]),
|
||||
sy.BeValueToken(["c"]),
|
||||
sy.BeAssignToken([["d", 14]]),
|
||||
], __GL()),
|
||||
],
|
||||
"optional": [
|
||||
# Optional element, should match any optional element
|
||||
("[a=12, b=13, 'c']", [
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
sy.BeAssignToken([["b", 13]]),
|
||||
sy.BeValueToken(["c"]),
|
||||
]),
|
||||
]),
|
||||
], __GL()),
|
||||
("[a=12, b=13, 'c', d=14]", [
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
sy.BeAssignToken([["b", 13]]),
|
||||
sy.BeValueToken(["c"]),
|
||||
sy.BeAssignToken([["d", 14]]),
|
||||
]),
|
||||
]),
|
||||
], __GL()),
|
||||
("[a=12]{aze,/.}", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
]),
|
||||
sy.OptionalInsertToken([
|
||||
"aze,/.",
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("{aze,/.}[a=12]", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalInsertToken([
|
||||
"aze,/.",
|
||||
]),
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("{aze!=}", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalInsertToken([
|
||||
"aze!=",
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("{{aze!=}}", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalClassToken([
|
||||
"aze!=",
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("{{aze!=}}{azett!=}", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalClassToken([
|
||||
"aze!=",
|
||||
]),
|
||||
sy.OptionalInsertToken([
|
||||
"azett!=",
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("{{aze!=}}{azett!=}[a=12]", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalClassToken([
|
||||
"aze!=",
|
||||
]),
|
||||
sy.OptionalInsertToken([
|
||||
"azett!=",
|
||||
]),
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
("[a=12]{aze,/.}{{azer!=}}", (
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 12]]),
|
||||
]),
|
||||
sy.OptionalInsertToken([
|
||||
"aze,/.",
|
||||
]),
|
||||
sy.OptionalClassToken([
|
||||
"azer!=",
|
||||
]),
|
||||
]),
|
||||
), __GL()),
|
||||
],
|
||||
# Enhanced Text
|
||||
"enhanced_text": [
|
||||
# Matches a line of text, with or without inline elements
|
||||
|
|
@ -155,7 +288,18 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
sy.EtStrikethroughToken(["~~"]), sy.TextToken(["Strikethrough"]),
|
||||
), __GL()),
|
||||
],
|
||||
|
||||
"html_insert": [
|
||||
# Match an HTML insert
|
||||
("{azer='\"}", (
|
||||
"azer='\"",
|
||||
), __GL()),
|
||||
],
|
||||
"class_insert": [
|
||||
# Match a class insert
|
||||
("{{azer='\"}}", (
|
||||
"azer='\"",
|
||||
), __GL()),
|
||||
],
|
||||
# Structural Elements
|
||||
"se_start": [
|
||||
# Matches a start of a structural element
|
||||
|
|
@ -245,7 +389,7 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
sy.OptionalInsertToken(["var='test', number=11"]),
|
||||
]),
|
||||
]),
|
||||
), __GL(), __XF),
|
||||
), __GL()),
|
||||
("#. Text8 [class='blue', 123]{var='test', number=11}", (
|
||||
sy.EtOlistToken([
|
||||
sy.TextToken(["Text8"]),
|
||||
|
|
@ -257,11 +401,11 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
sy.OptionalInsertToken(["var='test', number=11"]),
|
||||
]),
|
||||
]),
|
||||
), __GL(), __XF),
|
||||
), __GL()),
|
||||
("! Display9 ! [class='blue', 123]{var='test', number=11}", (
|
||||
sy.DisplayToken([
|
||||
"!",
|
||||
"Display9",
|
||||
"Display9 ",
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["class", "blue"]]),
|
||||
|
|
@ -270,11 +414,11 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
sy.OptionalInsertToken(["var='test', number=11"]),
|
||||
]),
|
||||
]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
), __GL()), # Bad optional implementation
|
||||
("## Text10 ## [class='blue', 123]{var='test', number=11}", (
|
||||
sy.HeaderToken([
|
||||
"##",
|
||||
"Text10",
|
||||
"Text10 ",
|
||||
sy.OptionalToken([
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["class", "blue"]]),
|
||||
|
|
@ -283,7 +427,7 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
sy.OptionalInsertToken(["var='test', number=11"]),
|
||||
]),
|
||||
]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
), __GL()), # Bad optional implementation
|
||||
],
|
||||
|
||||
# Tables
|
||||
|
|
@ -328,7 +472,7 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
"var='test', number=11",
|
||||
]),
|
||||
]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
), __GL()),
|
||||
],
|
||||
|
||||
"table_separator": [
|
||||
|
|
@ -357,6 +501,31 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
("|---|---|", (sy.TableSeparatorToken(["---", "---"]),), __GL()),
|
||||
("- Text", (sy.EtUlistToken([sy.TextToken(["Text"])]),), __GL()),
|
||||
("div>>", (sy.StructuralElementEndToken(["div"]),), __GL()),
|
||||
("#. Text with *em* and __underline__ and {arguments}{{super-arguments}}[a=1,'ui']", (
|
||||
sy.EtOlistToken([
|
||||
sy.TextToken(["Text with"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["em"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["and"]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["underline"]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["and"]),
|
||||
sy.OptionalToken([
|
||||
sy.OptionalInsertToken([
|
||||
"arguments",
|
||||
]),
|
||||
sy.OptionalClassToken([
|
||||
"super-arguments",
|
||||
]),
|
||||
sy.OptionalVarToken([
|
||||
sy.BeAssignToken([["a", 1]]),
|
||||
sy.BeValueToken(["ui"]),
|
||||
]),
|
||||
]),
|
||||
]),
|
||||
), __GL(),),
|
||||
],
|
||||
}
|
||||
|
||||
|
|
@ -368,6 +537,9 @@ zipped_dict_advanced_syntax_input_and_expected_output = [
|
|||
] for item in sublist
|
||||
]
|
||||
|
||||
__syntax_file = __module_path("syntax.py")
|
||||
__definition_of_syntax_elements = find_variables_in_file(__syntax_file, dict_advanced_syntax_input_and_expected_output.keys())
|
||||
|
||||
# test__add_tag
|
||||
list_add_tag_input_and_expected_output = [
|
||||
# Test cases for the add_tag function
|
||||
|
|
@ -421,6 +593,27 @@ list_of_text_input_and_readable_output = [
|
|||
]
|
||||
|
||||
|
||||
list_of_reparsing_input_and_expected_output = [
|
||||
("reparse_test", "enhanced_text", [sy.TextToken(["reparse_test"])], __GL()),
|
||||
("reparse text *bold*, __underlined__ (#123) Custom", "enhanced_text", [
|
||||
sy.TextToken(["reparse text"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["bold"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken([","]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["underlined"]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.EtCustomSpanToken(["123"]),
|
||||
sy.TextToken(["Custom"])
|
||||
], __GL())
|
||||
]
|
||||
final_list_of_reparsing_input_and_expected_output = [
|
||||
ptp(item[0], item[1], item[2], item[3], id=f'{item[0]} (line:{item[3]})', marks=item[4:])
|
||||
for item in list_of_reparsing_input_and_expected_output
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("token_name,token_class", list_of_token_types.items())
|
||||
def test_token_type_exists(token_name, token_class):
|
||||
"""
|
||||
|
|
@ -503,6 +696,9 @@ def test_semantic_type_eq():
|
|||
st1 = sy.SemanticType([1, 2, 3])
|
||||
st2 = sy.SemanticType([1, 2, 3, 4])
|
||||
assert st1 != st2
|
||||
st1 = sy.SemanticType([[1, 2, 4]])
|
||||
st2 = sy.SemanticType([[1, 2, 3]])
|
||||
assert st1 != st2
|
||||
|
||||
|
||||
def find_expression_from_str(expression_str):
|
||||
|
|
@ -551,8 +747,11 @@ def test_advanced_expression_and_token_creation(markup_element, to_parse, expect
|
|||
assert isinstance(expr, pyparsing.ParserElement)
|
||||
result = expr.parse_string(to_parse)
|
||||
print()
|
||||
print(f"Parsing expression: {to_parse} with {markup_element}")
|
||||
print(f"Parsing string: '{to_parse}'")
|
||||
print("Defined at %(filename)s:%(lineno)d" % {'filename': __file__, 'lineno': line_test})
|
||||
print(f"With expression: '{markup_element}'")
|
||||
print("Defined at %(filename)s:%(lineno)d" % {'filename': __syntax_file,
|
||||
'lineno': __definition_of_syntax_elements[markup_element]})
|
||||
print(f"Found: {result} (len:{len(result)}).")
|
||||
print(f"Expected: {expected} (len:{len(expected)})")
|
||||
assert result is not None
|
||||
|
|
@ -614,3 +813,33 @@ def test_weird_markup():
|
|||
|
||||
assert sy.readable_markup(
|
||||
[sy.EmptySemanticType("weird"), empty_token, WeirdClass()]) == "weird <[NOC] weird /> weird"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("original_string, reparse_with, expected_output, line_test",
|
||||
final_list_of_reparsing_input_and_expected_output)
|
||||
def test_reparse(original_string, reparse_with, expected_output, line_test):
|
||||
"""
|
||||
Test the reparse function
|
||||
"""
|
||||
print()
|
||||
print(f"Reparsing string: '{original_string}'")
|
||||
print("Defined at %(filename)s:%(lineno)d" % {'filename': __file__, 'lineno': int(line_test)})
|
||||
print(f"With expression: '{reparse_with}'")
|
||||
print("Defined at %(filename)s:%(lineno)d" % {'filename': __syntax_file,
|
||||
'lineno': __definition_of_syntax_elements[reparse_with]})
|
||||
print(f"Expected: {expected_output} (len:{len(expected_output)})")
|
||||
|
||||
expression = find_expression_from_str(str(reparse_with))
|
||||
reparse_action = pyparsing.Word(pyparsing.printables+" ").add_parse_action(sy.reparse(expression))
|
||||
reparse_result = reparse_action.parseString(str(original_string))
|
||||
print(f"Found: {reparse_result} (len:{len(reparse_result)}).")
|
||||
|
||||
assert reparse_result is not None
|
||||
for expected, result in zip_longest(expected_output, reparse_result):
|
||||
assert result == expected
|
||||
|
||||
|
||||
def test_empty_token():
|
||||
"""Test that empty tokens are correctly dropped."""
|
||||
|
||||
assert sy.of_type(sy.EmptySemanticType)("", [], []) is None
|
||||
|
|
|
|||
|
|
@ -0,0 +1,113 @@
|
|||
import inspect
|
||||
import os
|
||||
import re
|
||||
|
||||
|
||||
###############################################################################
|
||||
# List of tools for testing
|
||||
###############################################################################
|
||||
###############################################################################
|
||||
# Paths
|
||||
########################################
|
||||
|
||||
|
||||
def __base():
|
||||
"""
|
||||
Return the path of the main module (relative to the tests)
|
||||
:return: Path of the main module
|
||||
:rtype: str
|
||||
"""
|
||||
return "../../src/bootstraparse/"
|
||||
|
||||
|
||||
def __module_path(module_name):
|
||||
"""
|
||||
Return the path of the module module_name
|
||||
:param module_name: Name of the module
|
||||
:type module_name: str
|
||||
:return: Path of the module
|
||||
:rtype: str
|
||||
"""
|
||||
return os.path.normpath(os.path.join(os.path.dirname(__file__), __base(), "modules", module_name))
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Frame inspection
|
||||
########################################
|
||||
# Cursed frame inspection
|
||||
def __GL():
|
||||
return inspect.getframeinfo(inspect.currentframe().f_back).lineno
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Code inspection
|
||||
########################################
|
||||
def find_string_in_file(file_path, list_regex_to_find):
|
||||
"""
|
||||
Find the string in the file stream
|
||||
:param file_path: Path of the file
|
||||
:type file_path: str
|
||||
:param list_regex_to_find: List of string to find
|
||||
:type list_regex_to_find: list
|
||||
:return: Dict of string found and line number
|
||||
:rtype: dict
|
||||
"""
|
||||
dict_string_found = {}
|
||||
list_regex_to_find_left = [string for string in list_regex_to_find]
|
||||
with open(file_path, "r") as file:
|
||||
for line_number, line in enumerate(file):
|
||||
for string_number, regex_to_find in enumerate(list_regex_to_find_left):
|
||||
match = regex_to_find.search(line)
|
||||
if match:
|
||||
dict_string_found[match.group(1)] = line_number + 1
|
||||
list_regex_to_find_left.pop(string_number)
|
||||
break
|
||||
if not list_regex_to_find_left:
|
||||
break
|
||||
if list_regex_to_find_left:
|
||||
print("String not found: " + str(list_regex_to_find_left))
|
||||
return dict_string_found
|
||||
|
||||
|
||||
def find_functions_in_file(file_path, list_function_name):
|
||||
"""
|
||||
Find the function in the file stream
|
||||
:param file_path: Path of the file
|
||||
:type file_path: str
|
||||
:param list_function_name: List of function name to find
|
||||
:type list_function_name: iterable
|
||||
:return: Dict of function found and line number
|
||||
:rtype: dict
|
||||
"""
|
||||
return find_string_in_file(file_path, [re.compile(f"$def ({function_name})") for function_name in list_function_name])
|
||||
|
||||
|
||||
def find_classes_in_file(file_path, list_class_name):
|
||||
"""
|
||||
Find the class in the file stream
|
||||
:param file_path: Path of the file
|
||||
:type file_path: str
|
||||
:param list_class_name: List of class name to find
|
||||
:type list_class_name: iterable
|
||||
:return: Dict of class found and line number
|
||||
:rtype: dict
|
||||
"""
|
||||
return find_string_in_file(file_path, [re.compile(f"^class ({class_name})") for class_name in list_class_name])
|
||||
|
||||
|
||||
def find_variables_in_file(file_path, list_variable_name):
|
||||
"""
|
||||
Find the variable in the file stream
|
||||
:param file_path: Path of the file
|
||||
:type file_path: str
|
||||
:param list_variable_name: List of variable name to find
|
||||
:type list_variable_name: iterable
|
||||
:return: Dict of variable found and line number
|
||||
:rtype: dict
|
||||
"""
|
||||
return find_string_in_file(file_path, [re.compile(f"^({variable_name}) ?=") for variable_name in list_variable_name])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# print(find_string_in_file(__module_path("syntax.py"), [re.compile(r"^(html_insert) ?=")]))
|
||||
pass
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
# Enhanced text
|
||||
italics:
|
||||
bpr: '*italics*'
|
||||
markdown compatible: yes
|
||||
additional unsupported markdown syntax: '_italics_'
|
||||
accepts arguments: no
|
||||
type: enhanced text
|
||||
scope: first release
|
||||
|
||||
bold:
|
||||
bpr: '**bold**'
|
||||
markdown compatible: yes
|
||||
accepts arguments: no
|
||||
type: enhanced text
|
||||
scope: first release
|
||||
|
||||
strikethrough:
|
||||
bpr: '~~strikethrough~~'
|
||||
markdown compatible: yes
|
||||
accepts arguments: no
|
||||
type: enhanced text
|
||||
scope: first release
|
||||
|
||||
underline:
|
||||
bpr: '__underline__'
|
||||
markdown compatible: no
|
||||
accepts arguments: no
|
||||
type: enhanced text
|
||||
scope: first release
|
||||
|
||||
|
||||
# In-line elements
|
||||
hyperlinks:
|
||||
bpr: '[text]("hyperlink")'
|
||||
markdown compatible: yes
|
||||
accepts arguments: no
|
||||
type: in-line
|
||||
scope: first release
|
||||
|
||||
# Pre-parsing elements
|
||||
aliases:
|
||||
bpr: '@[alias]'
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
type: pre-parsing
|
||||
scope: first release
|
||||
|
||||
images:
|
||||
bpr: '@{image}'
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
type: pre-parsing
|
||||
scope: first release
|
||||
|
||||
# One-line elements
|
||||
headers:
|
||||
bpr: '# header #'
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: no
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
display:
|
||||
bpr: '! header !'
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: no
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
# Not sure about sublists for the moment, add that later
|
||||
numbered lists:
|
||||
bpr: '#. nbd list item'
|
||||
markdown compatible: no
|
||||
accepts arguments: no
|
||||
accepts enhanced text: yes
|
||||
additional unsupported features: sub-lists
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
bullet lists:
|
||||
bpr: '- list item'
|
||||
markdown compatible: yes
|
||||
accepts arguments: no
|
||||
accepts enhanced text: yes
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
|
||||
# Multi-line elements
|
||||
structural elements:
|
||||
bpr: '<<start /// end>>'
|
||||
accepted elements: div, article, aside, section
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
type: multi-line
|
||||
scope: first release
|
||||
|
||||
tables:
|
||||
bpr: '| table cell |'
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: yes
|
||||
type: multi-line
|
||||
scope: first release
|
||||
|
||||
table-separator:
|
||||
bpr: '|-----------|'
|
||||
# accepts ':' either at the start, middle or end of the line to align text for the column
|
||||
# putting a separator after a row will change said row to table-header
|
||||
# putting a separator after a column will change said column to table-header
|
||||
markdown compatible: no
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: yes
|
||||
type: multi-line
|
||||
scope: first release
|
||||
|
||||
|
||||
# # Things to add
|
||||
blockquotes:
|
||||
bpr: '> quote'
|
||||
markdown compatible: yes
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: yes
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
code:
|
||||
bpr: '`quote`'
|
||||
markdown compatible: yes
|
||||
accepts arguments: no
|
||||
accepts enhanced text: no
|
||||
type: in-line
|
||||
scope: post-release
|
||||
|
||||
code-blocks:
|
||||
bpr: '```quote```'
|
||||
markdown compatible: yes
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: no
|
||||
type: multi-line
|
||||
scope: post-release
|
||||
|
||||
horizontal rule:
|
||||
bpr: '---'
|
||||
markdown compatible: yes
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: no
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
reference-style link:
|
||||
bpr: '[digit]("hyperlink")'
|
||||
markdown syntax: '[link][digit]' # needs testing, unclear
|
||||
accepts arguments: yes
|
||||
accepts enhanced text: no
|
||||
type: one-line
|
||||
scope: first release
|
||||
|
||||
# Inline-style link with title
|
||||
Loading…
Reference in New Issue