Added some cursed frame inspection to get line numbers, formatted some tests.
This commit is contained in:
parent
8e694a87da
commit
5694596f90
|
|
@ -164,6 +164,8 @@ def of_type(token_class):
|
|||
:return: returns a function creating an instance of the given class
|
||||
"""
|
||||
def _of_type(_, __, content):
|
||||
if len(content) == 0: # Drop Empty token
|
||||
return None
|
||||
return token_class(content)
|
||||
|
||||
return _of_type
|
||||
|
|
@ -199,12 +201,18 @@ url_characters = pp.common.url
|
|||
# Composite elements
|
||||
var = '[' + pp.delimitedList(assignation ^ value)("list_vars").set_name("list_vars") + ']'
|
||||
|
||||
|
||||
# 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 = '{' + expression('html_insert') + '}'
|
||||
|
||||
# Optional elements
|
||||
optional = (
|
||||
pp.Opt(html_insert)("html_insert") & pp.Opt(var)("var")
|
||||
)("optional").add_parse_action(of_type(OptionalToken))
|
||||
|
||||
# Structural elements
|
||||
structural_elements = (
|
||||
pp.CaselessLiteral('div') |
|
||||
pp.CaselessLiteral('article') |
|
||||
|
|
@ -214,12 +222,6 @@ structural_elements = (
|
|||
header_element = pp.Word('#')
|
||||
display_element = pp.Word('!')
|
||||
|
||||
|
||||
# Optional elements
|
||||
optional = pp.Opt(
|
||||
pp.Opt(html_insert)("html_insert") + pp.Opt(var)("var")
|
||||
)("optional").add_parse_action(of_type(OptionalToken))
|
||||
|
||||
# Inline elements
|
||||
il_link = pp.Regex(
|
||||
r"""\[(?P<text>.+)\]\(['"](?P<url>[a-zA-Z-_:\/=@#!%\?\d\(\)\.]+)['"]\)"""
|
||||
|
|
@ -233,6 +235,7 @@ et_strikethrough = pp.Literal('~~')('strikethrough').add_parse_action(of_type(Et
|
|||
et_custom_span = (
|
||||
pps('(#') + pp.Word(pp.nums)('span_id') + pps(')')
|
||||
).set_name('custom_span').add_parse_action(of_type(EtCustomSpanToken))
|
||||
|
||||
# markup sums up all in-line elements
|
||||
markup = il_link | et_strong | et_em | et_strikethrough | et_underline | et_custom_span
|
||||
enhanced_text = pp.ZeroOrMore(
|
||||
|
|
@ -241,17 +244,18 @@ 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)) # TODO: + pp.Opt(optional)
|
||||
se_end = (structural_elements + pps('>>')).add_parse_action(of_type(StructuralElementEndToken)) + optional
|
||||
se = se_end | se_start # Structural element
|
||||
table_row = pp.OneOrMore(
|
||||
# pp.Regex(r'\|(\d)?')('table_colspan') +
|
||||
(pp.Combine(pps('|') + pp.Word(pp.nums)('table_colspan')) | pps('|')) +
|
||||
pp.SkipTo('|')('table_cell').add_parse_action(of_type(TableCellToken)) # TODO: account for enhanced text
|
||||
).add_parse_action(of_type(TableRowToken)) + pps('|') # TODO: + pp.Opt(optional)
|
||||
).add_parse_action(of_type(TableRowToken)) + pps('|') + pp.Opt(optional)
|
||||
table_separator = pp.OneOrMore(
|
||||
pps('|') + pp.Word(':-')
|
||||
)('table_separator').add_parse_action(of_type(TableSeparatorToken)) + pps('|')
|
||||
)('table_separator').add_parse_action(of_type(TableSeparatorToken)) + pps('|') # TODO: Tokenize table separator ?
|
||||
table = table_separator | table_row
|
||||
|
||||
# multi_line sums up all multi-line elements
|
||||
multi_line = se | table
|
||||
|
||||
|
|
@ -259,7 +263,6 @@ multi_line = se | table
|
|||
one_header = (
|
||||
header_element + pp.SkipTo(pp.match_previous_literal(header_element))
|
||||
).add_parse_action(of_type(HeaderToken))
|
||||
# TODO : Add display to tests
|
||||
one_display = (
|
||||
display_element + pp.SkipTo(pp.match_previous_literal(display_element))
|
||||
).add_parse_action(of_type(DisplayToken))
|
||||
|
|
@ -269,8 +272,9 @@ one_olist = pp.line_start + (
|
|||
one_ulist = pp.line_start + (
|
||||
pps(pp.Literal('-')) + enhanced_text('ulist_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 # TODO: + pp.Opt(optional)
|
||||
one_line = (one_header | one_display | one_olist | one_ulist) + pp.Opt(optional)
|
||||
|
||||
# Final elements
|
||||
line = one_line | multi_line | enhanced_text
|
||||
|
|
|
|||
|
|
@ -2,10 +2,19 @@ from itertools import zip_longest
|
|||
|
||||
import pyparsing
|
||||
import pytest
|
||||
import inspect
|
||||
|
||||
|
||||
import bootstraparse.modules.syntax as sy
|
||||
|
||||
|
||||
ptp = pytest.param
|
||||
__XF = pytest.mark.xfail
|
||||
|
||||
|
||||
# Cursed frame inspection
|
||||
def __GL():
|
||||
return inspect.getframeinfo(inspect.currentframe().f_back).lineno
|
||||
|
||||
|
||||
##############################################################################################################
|
||||
|
|
@ -78,159 +87,242 @@ dict_advanced_syntax_input_and_expected_output = {
|
|||
# Enhanced text
|
||||
"et_em": [
|
||||
# Single em element, should only match the first "*"
|
||||
("*", (sy.EtEmToken(["*"]),)),
|
||||
("*", (sy.EtEmToken(["*"]),), __GL()),
|
||||
],
|
||||
"et_strong": [
|
||||
# Single strong element, should only match the first "**"
|
||||
("**", (sy.EtStrongToken(["**"]),)),
|
||||
("**", (sy.EtStrongToken(["**"]),), __GL()),
|
||||
],
|
||||
"et_underline": [
|
||||
# Single underline element, should only match the first "__"
|
||||
("__", (sy.EtUnderlineToken(["__"]),)),
|
||||
("__", (sy.EtUnderlineToken(["__"]),), __GL()),
|
||||
],
|
||||
"et_strikethrough": [
|
||||
# Single strikethrough element, should only match the first "~~"
|
||||
("~~", (sy.EtStrikethroughToken(["~~"]),)),
|
||||
("~~", (sy.EtStrikethroughToken(["~~"]),), __GL()),
|
||||
],
|
||||
"et_custom_span": [
|
||||
# Single custom span element, should only match the first "(#number)"
|
||||
("(#12345)", (sy.EtCustomSpanToken(["12345"]),)),
|
||||
("(#12345)", (sy.EtCustomSpanToken(["12345"]),), __GL()),
|
||||
],
|
||||
"il_link": [
|
||||
# Single link element, should only match the first "[link_name]('link')"
|
||||
("[text_link]('text://www.website.com/link.html')",
|
||||
[sy.HyperlinkToken(["[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
|
||||
# Enhanced Text
|
||||
"enhanced_text": [
|
||||
# Matches a line of text, with or without inline elements
|
||||
("*test*", (sy.EtEmToken(["*"]), sy.TextToken(["test"]), sy.EtEmToken(["*"]))),
|
||||
("**test**", (sy.EtStrongToken(["**"]), sy.TextToken(["test"]), sy.EtStrongToken(["**"]))),
|
||||
("__test__", (sy.EtUnderlineToken(["__"]), sy.TextToken(["test"]), sy.EtUnderlineToken(["__"]))),
|
||||
("~~test~~", (sy.EtStrikethroughToken(["~~"]), sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]))),
|
||||
("(#12345)", (sy.EtCustomSpanToken(["12345"]),)),
|
||||
("*test*", (sy.EtEmToken(["*"]), sy.TextToken(["test"]), sy.EtEmToken(["*"])), __GL()),
|
||||
("**test**", (sy.EtStrongToken(["**"]), sy.TextToken(["test"]), sy.EtStrongToken(["**"])), __GL()),
|
||||
("__test__", (sy.EtUnderlineToken(["__"]), sy.TextToken(["test"]), sy.EtUnderlineToken(["__"])), __GL()),
|
||||
("~~test~~", (sy.EtStrikethroughToken(["~~"]), sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"])), __GL()),
|
||||
("(#12345)", (sy.EtCustomSpanToken(["12345"]),), __GL()),
|
||||
("*test*test*", (sy.EtEmToken(["*"]), sy.TextToken(["test"]), sy.EtEmToken(["*"]), sy.TextToken(["test"]),
|
||||
sy.EtEmToken(["*"]))),
|
||||
sy.EtEmToken(["*"])), __GL()),
|
||||
("**test**test**",
|
||||
(sy.EtStrongToken(["**"]), sy.TextToken(["test"]), sy.EtStrongToken(["**"]), sy.TextToken(["test"]),
|
||||
sy.EtStrongToken(["**"]),)),
|
||||
sy.EtStrongToken(["**"]),), __GL()),
|
||||
("__test__test__", (sy.EtUnderlineToken(["__"]), sy.TextToken(["test"]), sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["test"]), sy.EtUnderlineToken(["__"]),)),
|
||||
sy.TextToken(["test"]), sy.EtUnderlineToken(["__"]),), __GL()),
|
||||
("~~test~~test~~", (sy.EtStrikethroughToken(["~~"]), sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]),
|
||||
sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]),)),
|
||||
sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]),), __GL()),
|
||||
("(#12345)test(#12345)", (sy.EtCustomSpanToken(["12345"]), sy.TextToken(["test"]),
|
||||
sy.EtCustomSpanToken(["12345"]),)),
|
||||
sy.EtCustomSpanToken(["12345"]),), __GL()),
|
||||
("__test(#12)test**test__test~~", (sy.EtUnderlineToken(["__"]), sy.TextToken(["test"]),
|
||||
sy.EtCustomSpanToken(["12"]), sy.TextToken(["test"]),
|
||||
sy.EtStrongToken(["**"]),
|
||||
sy.TextToken(["test"]), sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]),)),
|
||||
("Test text with a link [link_name]('link')",
|
||||
(sy.TextToken(["Test text with a link"]), sy.HyperlinkToken(["[link_name]('link')"]),)),
|
||||
# noqa E501 (line too long)
|
||||
("Test text with a link [link_name](\"link\") and a *bold* text", (sy.TextToken(["Test text with a link"]),
|
||||
sy.HyperlinkToken(['[link_name]("link")']),
|
||||
sy.TextToken(["and a"]), sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["bold"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["text"]),
|
||||
)),
|
||||
("Reverse order (#123) Span __ Underline ~~ Strikethrough",
|
||||
(sy.TextToken(["Reverse order"]),
|
||||
sy.EtCustomSpanToken(["123"]), sy.TextToken(["Span"]),
|
||||
sy.EtUnderlineToken(["__"]), sy.TextToken(["Underline"]),
|
||||
sy.EtStrikethroughToken(["~~"]), sy.TextToken(["Strikethrough"]),)), # noqa E501 (line too long)
|
||||
sy.TextToken(["test"]), sy.EtStrikethroughToken(["~~"]),), __GL()),
|
||||
("Test text with a link [link_name]('link')", (
|
||||
sy.TextToken(["Test text with a link"]),
|
||||
sy.HyperlinkToken(["[link_name]('link')"]),
|
||||
), __GL()),
|
||||
("Test text with a link [link_name](\"link\") and a *bold* text", (
|
||||
sy.TextToken(["Test text with a link"]),
|
||||
sy.HyperlinkToken(['[link_name]("link")']),
|
||||
sy.TextToken(["and a"]), sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["bold"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["text"]),
|
||||
), __GL()),
|
||||
("Reverse order (#123) Span __ Underline ~~ Strikethrough", (
|
||||
sy.TextToken(["Reverse order"]),
|
||||
sy.EtCustomSpanToken(["123"]), sy.TextToken(["Span"]),
|
||||
sy.EtUnderlineToken(["__"]), sy.TextToken(["Underline"]),
|
||||
sy.EtStrikethroughToken(["~~"]), sy.TextToken(["Strikethrough"]),
|
||||
), __GL()),
|
||||
],
|
||||
|
||||
# Structural Elements
|
||||
"se_start": [
|
||||
# Matches a start of a structural element
|
||||
("<<div", (sy.StructuralElementStartToken(["div"]),)),
|
||||
("<<div", (sy.StructuralElementStartToken(["div"]),), __GL()),
|
||||
],
|
||||
"se_end": [
|
||||
("div>>", (sy.StructuralElementEndToken(["div"]),)),
|
||||
("div>>", (sy.StructuralElementEndToken(["div"]),), __GL()),
|
||||
],
|
||||
# "se": [
|
||||
"se": [
|
||||
# Matches a div element, must be at the beginning of the line, the closing div can be with arguments
|
||||
# TODO : Re-implement this
|
||||
# ("div>> [class='blue', 123#]{var='test', number=11}", [sy.StructuralElementEndToken(["div", [
|
||||
# sy.OptionalToken(["[", "class='blue'", ",", "123#", "]", "{", "var='test'", ",", "number=11", "}"])]])]),
|
||||
("div>> [class='blue', 123]{var='test', number=11}", (
|
||||
sy.StructuralElementEndToken(["div"]),
|
||||
sy.OptionalToken(["[", ["class", "=", "'blue'"], 123, "]", "{", "var='test'", "number=11", "}"]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
# ("div>> [class='blue', 123#]",
|
||||
# [sy.StructuralElementEndToken(["div", [sy.OptionalToken(["[", "class='blue'", ",", "123#", "]"])]])]),
|
||||
# ("div>> {var='test', number=11}",
|
||||
# [sy.StructuralElementEndToken(["div", [sy.OptionalToken(["{", "var='test'", ",", "number=11", "}"])]])]),
|
||||
# ],
|
||||
],
|
||||
|
||||
# List Elements
|
||||
# TODO: Test markup in lists
|
||||
# TODO: Test markup and add optionnals in lists
|
||||
"one_olist": [
|
||||
# Matches a one-level ordered list element, must be at the beginning of the line
|
||||
# Drop the "." from the match
|
||||
("#. Text", (sy.EtOlistToken([sy.TextToken(["Text"])]),)),
|
||||
("#. Text", (sy.EtOlistToken([sy.TextToken(["Text"])]),), __GL()),
|
||||
],
|
||||
"one_ulist": [
|
||||
# Matches a one-level unordered list element, must be at the beginning of the line
|
||||
# Drop the "-" from the match
|
||||
("- Text", (sy.EtUlistToken([sy.TextToken(["Text"])]),)),
|
||||
("- Text", (sy.EtUlistToken([sy.TextToken(["Text"])]),), __GL()),
|
||||
],
|
||||
|
||||
# Headers
|
||||
"one_header": [
|
||||
# Matches a one-level header element, must be at the beginning of the line
|
||||
("# Text1 #", (sy.HeaderToken(["#", "Text1 "]),)),
|
||||
("## Text2 ##", (sy.HeaderToken(["##", "Text2 "]),)),
|
||||
("### Text3 ###", (sy.HeaderToken(["###", "Text3 "]),)),
|
||||
("#### Text4 ####", (sy.HeaderToken(["####", "Text4 "]),)),
|
||||
("##### Text5 #####", (sy.HeaderToken(["#####", "Text5 "]),)),
|
||||
("###### Text6 ######", (sy.HeaderToken(["######", "Text6 "]),)),
|
||||
# TODO : Re-implement that
|
||||
# ("## Text2 ## {var='test', number=11}", (sy.HeaderToken(["##", "Text2 "]),
|
||||
# sy.OptionalToken(["{", "var='test'", ",", "number=11", "}"]))),
|
||||
# ("### Text3 ### [class='blue', 123#]{var='test', number=11}", (sy.HeaderToken(["###", "Text3 "]),
|
||||
# sy.OptionalToken(
|
||||
# ["[", "class='blue'", ",", "123#", "]"]),
|
||||
# # noqa E501 (line too long)
|
||||
# sy.OptionalToken(
|
||||
# ["{", "var='test'", ",", "number=11",
|
||||
# "}"]))), # noqa E501 (line too long)
|
||||
("# Text1 #", (sy.HeaderToken(["#", "Text1 "]),), __GL()),
|
||||
("## Text2 ##", (sy.HeaderToken(["##", "Text2 "]),), __GL()),
|
||||
("### Text3 ###", (sy.HeaderToken(["###", "Text3 "]),), __GL()),
|
||||
("#### Text4 ####", (sy.HeaderToken(["####", "Text4 "]),), __GL()),
|
||||
("##### Text5 #####", (sy.HeaderToken(["#####", "Text5 "]),), __GL()),
|
||||
("###### Text6 ######", (sy.HeaderToken(["######", "Text6 "]),), __GL()),
|
||||
],
|
||||
|
||||
# One-line display elements
|
||||
"one_display": [
|
||||
# Matches a one-level display element, must be at the beginning of the line
|
||||
("! Display1 !", (sy.DisplayToken(["!", "Display1 "]),), __GL()),
|
||||
("!! Display2 !!", (sy.DisplayToken(["!!", "Display2 "]),), __GL()),
|
||||
("!!! Display3 !!!", (sy.DisplayToken(["!!!", "Display3 "]),), __GL()),
|
||||
],
|
||||
|
||||
# One-line elements
|
||||
"one_line": [
|
||||
# Matches a one-line element, must be at the beginning of the line
|
||||
("- Text1", (sy.EtUlistToken([sy.TextToken(["Text1"])]),), __GL()),
|
||||
("#. Text2", (sy.EtOlistToken([sy.TextToken(["Text2"])]),), __GL()),
|
||||
("! Display3 !", (sy.DisplayToken(["!", "Display3 "]),), __GL()),
|
||||
("!! Display4 !!", (sy.DisplayToken(["!!", "Display4 "]),), __GL()),
|
||||
("### Text5 ###", (sy.HeaderToken(["###", "Text5 "]),), __GL()),
|
||||
("#### Text6 ####", (sy.HeaderToken(["####", "Text6 "]),), __GL()),
|
||||
("- Text7 [class='blue', 123]{var='test', number=11}", (
|
||||
sy.EtUlistToken([
|
||||
sy.TextToken(["Text7"]),
|
||||
sy.OptionalToken(["[", "class='blue'", ",", "123#", "]", "{", "var='test'", ",", "number=11", "}"])
|
||||
]),
|
||||
), __GL(), __XF),
|
||||
("#. Text8 [class='blue', 123]{var='test', number=11}", (
|
||||
sy.EtOlistToken([
|
||||
sy.TextToken(["Text8"]),
|
||||
sy.OptionalToken(["[", "class='blue'", ",", "123", "]", "{", "var='test'", ",", "number=11", "}"])
|
||||
]),
|
||||
), __GL(), __XF),
|
||||
("! Display9 ! [class='blue', 123]{var='test', number=11}", (
|
||||
sy.DisplayToken([
|
||||
"!",
|
||||
"Display9",
|
||||
sy.OptionalToken([
|
||||
"[", "class='blue'", ",", "123", "]",
|
||||
"{", "var='test'", ",", "number=11", "}"
|
||||
])
|
||||
]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
("## Text10 ## [class='blue', 123]{var='test', number=11}", (
|
||||
sy.HeaderToken([
|
||||
"##",
|
||||
"Text10",
|
||||
sy.OptionalToken([
|
||||
"[", "class='blue'", ",", "123", "]",
|
||||
"{", "var='test'", ",", "number=11", "}"])
|
||||
]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
],
|
||||
|
||||
# Tables
|
||||
"table_row": [
|
||||
# Matches a table element, must be at the beginning of the line
|
||||
("| Text1 | Text2 |", (sy.TableRowToken([sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "]),]),)),
|
||||
("| Text1 | Text2 | Text3 |", (sy.TableRowToken([sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "]), sy.TableCellToken(["Text3 "])]),)),
|
||||
("| 2 Text1 | Text2 |", (sy.TableRowToken([sy.TableCellToken(["2 Text1 "]), sy.TableCellToken(["Text2 "])]),)),
|
||||
("|2 Text1 | Text2 |", (sy.TableRowToken(['2', sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "])]),)),
|
||||
("|2 Text1 |3 Text2 |", (sy.TableRowToken(['2', sy.TableCellToken(["Text1 "]), '3', sy.TableCellToken(["Text2 "])]),)),
|
||||
# ("|2 Text1 |3 Text2 |4 Text3 |", (sy.TableRowToken(["|2", "Text1", "|3", "Text2", "|4", "Text3", "|"]),)),
|
||||
# ("|3 Text1 | Text2 | {var='test', number=11}", (sy.TableRowToken(["|3", "Text1", "|", "Text2", "|"]),
|
||||
# sy.UnimplementedToken(
|
||||
# ["{", "var='test'", ",", "number=11", "}"]))),
|
||||
("| Text1 | Text2 |", (sy.TableRowToken([sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "]), ]), ), __GL()),
|
||||
("| Text1 | Text2 | Text3 |", (
|
||||
sy.TableRowToken([
|
||||
sy.TableCellToken(["Text1 "]),
|
||||
sy.TableCellToken(["Text2 "]),
|
||||
sy.TableCellToken(["Text3 "])
|
||||
]),
|
||||
), __GL()),
|
||||
("| 2 Text1 | Text2 |", (sy.TableRowToken([sy.TableCellToken(["2 Text1 "]), sy.TableCellToken(["Text2 "])]),), __GL()),
|
||||
("|2 Text1 | Text2 |", (
|
||||
sy.TableRowToken([
|
||||
'2',
|
||||
sy.TableCellToken(["Text1 "]),
|
||||
sy.TableCellToken(["Text2 "]),
|
||||
]),
|
||||
), __GL()),
|
||||
("|2 Text1 |3 Text2 |", (
|
||||
sy.TableRowToken(['2', sy.TableCellToken(["Text1 "]), '3', sy.TableCellToken(["Text2 "])]),
|
||||
), __GL()),
|
||||
("|2 Text1 |3 Text2 |4 Text3 |", (
|
||||
sy.TableRowToken([
|
||||
'2',
|
||||
sy.TableCellToken(["Text1 "]),
|
||||
'3',
|
||||
sy.TableCellToken(["Text2 "]),
|
||||
'4',
|
||||
sy.TableCellToken(["Text3 "])]),
|
||||
), __GL()),
|
||||
("|3 Text1 | Text2 | {var='test', number=11}", (
|
||||
sy.TableRowToken([
|
||||
'3',
|
||||
sy.TableCellToken(["Text1 "]),
|
||||
sy.TableCellToken(["Text2 "]),
|
||||
]),
|
||||
sy.OptionalToken(["{", "var='test'", "number=11", "}"]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
],
|
||||
|
||||
"table_separator": [
|
||||
# Matches a table element, must be at the beginning of the line # TODO: Tokens ?
|
||||
("|---|---|", (sy.TableSeparatorToken(["---", "---"]),)),
|
||||
("|---|---|---|", (sy.TableSeparatorToken(["---", "---", "---"]),)),
|
||||
("|:--|-:-|--:|--:|", (sy.TableSeparatorToken([":--", "-:-", "--:", "--:"]),)),
|
||||
# Matches a table element, must be at the beginning of the line
|
||||
("|---|---|", (sy.TableSeparatorToken(["---", "---"]),), __GL()),
|
||||
("|---|---|---|", (sy.TableSeparatorToken(["---", "---", "---"]),), __GL()),
|
||||
("|:--|-:-|--:|--:|", (sy.TableSeparatorToken([":--", "-:-", "--:", "--:"]),), __GL()),
|
||||
],
|
||||
|
||||
"line": [
|
||||
# Match any line parsed by the parser (can match header, list table etc...) this is the main syntax element
|
||||
("# Text1 #", (sy.HeaderToken(["#", "Text1 "]),)),
|
||||
# TODO: old testing, needs freshening up
|
||||
# ("Text *bold __underline__ still bold*", (
|
||||
# sy.TextToken(["Text ", sy.EtStrongToken(["bold", " ", sy.EtUnderlineToken(["underline"]), " still bold"])]),)), # noqa E501 (line too long)
|
||||
("|2 Text1 | Text2 |", (sy.TableRowToken(["2", sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "])]),)),
|
||||
("|---|---|", (sy.TableSeparatorToken(["---", "---"]),)),
|
||||
("- Text", (sy.EtUlistToken([sy.TextToken(["Text"])]),)),
|
||||
("div>>", (sy.StructuralElementEndToken(["div"]),)),
|
||||
("# Text1 #", (sy.HeaderToken(["#", "Text1 "]),), __GL()),
|
||||
("Text *em __underline__ still em*", (
|
||||
sy.TextToken(["Text "]),
|
||||
sy.EtEmToken(["*"]),
|
||||
sy.TextToken(["em "]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["underline"]),
|
||||
sy.EtUnderlineToken(["__"]),
|
||||
sy.TextToken(["still em"]),
|
||||
sy.EtEmToken(["*"]),
|
||||
), __GL(), __XF), # Bad optional implementation
|
||||
("|2 Text1 | Text2 |", (
|
||||
sy.TableRowToken(["2", sy.TableCellToken(["Text1 "]), sy.TableCellToken(["Text2 "])]),
|
||||
), __GL()),
|
||||
("|---|---|", (sy.TableSeparatorToken(["---", "---"]),), __GL()),
|
||||
("- Text", (sy.EtUlistToken([sy.TextToken(["Text"])]),), __GL()),
|
||||
("div>>", (sy.StructuralElementEndToken(["div"]),), __GL()),
|
||||
],
|
||||
}
|
||||
|
||||
# Cursed zipping oneline
|
||||
zipped_dict_advanced_syntax_input_and_expected_output = [
|
||||
ptp(item[0], item[1][0], item[1][1], id=f"{item[0]}@{item[1][0][:8]} @") for sublist in [
|
||||
ptp(item[0], item[1][0], item[1][1], item[1][2], marks=item[1][3:], id=f"{item[0]} [line {item[1][2]}]") for sublist in [
|
||||
zip_longest([key], dict_advanced_syntax_input_and_expected_output[key], fillvalue=key) for key in
|
||||
dict_advanced_syntax_input_and_expected_output.keys() # noqa E501 (line too cursed)
|
||||
] for item in sublist
|
||||
|
|
@ -318,7 +410,7 @@ def test_of_type_creator(token_class):
|
|||
:type token_class: sy.SemanticType
|
||||
"""
|
||||
fcr = sy.of_type(token_class)
|
||||
tnk = fcr(None, None, None)
|
||||
tnk = fcr(None, None, ['Text'])
|
||||
# noinspection PyTypeChecker
|
||||
assert isinstance(tnk, token_class) # pylint: disable=unidiomatic-typecheck
|
||||
assert tnk.label == token_class.label
|
||||
|
|
@ -401,22 +493,28 @@ def test_expression_matching(expression, to_parse):
|
|||
assert expr.parse_string(string) is not None
|
||||
|
||||
|
||||
@pytest.mark.parametrize("markup_element, to_parse, expected", zipped_dict_advanced_syntax_input_and_expected_output)
|
||||
def test_advanced_expression_and_token_creation(markup_element, to_parse, expected):
|
||||
@pytest.mark.parametrize("markup_element, to_parse, expected, line_test", zipped_dict_advanced_syntax_input_and_expected_output) # noqa: E501 (line too long)
|
||||
def test_advanced_expression_and_token_creation(markup_element, to_parse, expected, line_test):
|
||||
"""
|
||||
Test that the advanced syntax is correctly parsed and returns the correct tokens.
|
||||
:param markup_element: The expression to test.
|
||||
:param to_parse: The string to test.
|
||||
:param expected: The expected tokens.
|
||||
:param line_test: The line number of the test.
|
||||
:type markup_element: str
|
||||
:type to_parse: str
|
||||
:type expected: list
|
||||
:type line_test: int
|
||||
"""
|
||||
expr = find_expression_from_str(markup_element)
|
||||
|
||||
assert isinstance(expr, pyparsing.ParserElement)
|
||||
result = expr.parse_string(to_parse)
|
||||
print(f"Found: {result} (len:{len(result)}). Expected {expected} (len:{len(expected)})")
|
||||
print()
|
||||
print(f"Parsing expression: {to_parse} with {markup_element}")
|
||||
print("Defined at %(filename)s:%(lineno)d" % {'filename': __file__, 'lineno': line_test})
|
||||
print(f"Found: {result} (len:{len(result)}).")
|
||||
print(f"Expected: {expected} (len:{len(expected)})")
|
||||
assert result is not None
|
||||
if len(result) != len(expected):
|
||||
raise ReturnArgumentSizeError(len(expected), len(result))
|
||||
|
|
|
|||
Loading…
Reference in New Issue