def test__parser__grammar_sequence(seg_list, caplog):
"""Test the Sequence grammar."""
bs = StringParser("bar", KeywordSegment)
fs = StringParser("foo", KeywordSegment)
g = Sequence(bs, fs)
# If running in the test environment, assert that Sequence recognises this
if getenv("SQLFLUFF_TESTENV", ""):
assert g.test_env
gc = Sequence(bs, fs, allow_gaps=False)
with RootParseContext(dialect=None) as ctx:
with caplog.at_level(logging.DEBUG, logger="sqlfluff.parser"):
# Should be able to match the list using the normal matcher
logging.info("#### TEST 1")
m = g.match(seg_list, parse_context=ctx)
assert m
assert len(m) == 3
assert m.matched_segments == (
KeywordSegment("bar", seg_list[0].pos_marker),
seg_list[1], # This will be the whitespace segment
KeywordSegment("foo", seg_list[2].pos_marker),
)
# Shouldn't with the allow_gaps matcher
logging.info("#### TEST 2")
assert not gc.match(seg_list, parse_context=ctx)
# Shouldn't match even on the normal one if we don't start at the beginning
logging.info("#### TEST 2")
assert not g.match(seg_list[1:], parse_context=ctx)
def test__parser__grammar_oneof_take_longest_match(seg_list):
"""Test that the OneOf grammar takes the longest match."""
fooRegex = ReSegment.make(r"fo{2}")
baar = KeywordSegment.make(
"baar",
)
foo = KeywordSegment.make(
"foo",
)
fooBaar = Sequence(
foo,
baar,
)
# Even if fooRegex comes first, fooBaar
# is a longer match and should be taken
g = OneOf(fooRegex, fooBaar)
with RootParseContext(dialect=None) as ctx:
assert fooRegex.match(seg_list[2:], parse_context=ctx).matched_segments == (
fooRegex("foo", seg_list[2].pos_marker),
)
assert g.match(seg_list[2:], parse_context=ctx).matched_segments == (
foo("foo", seg_list[2].pos_marker),
baar("baar", seg_list[3].pos_marker),
)
def test__parser__grammar_sequence_indent_conditional(seg_list, caplog):
"""Test the Sequence grammar with indents."""
bs = StringParser("bar", KeywordSegment)
fs = StringParser("foo", KeywordSegment)
# We will assume the default config has indented_joins = False.
# We're testing without explictly setting the `config_type` because
# that's the assumed way of using the grammar in practice.
g = Sequence(
Conditional(Indent, indented_joins=False),
bs,
Conditional(Indent, indented_joins=True),
fs,
)
with RootParseContext(dialect=None) as ctx:
with caplog.at_level(logging.DEBUG, logger="sqlfluff.parser"):
m = g.match(seg_list, parse_context=ctx)
assert m
# Check we get an Indent.
assert isinstance(m.matched_segments[0], Indent)
assert isinstance(m.matched_segments[1], KeywordSegment)
# check the whitespace is still there
assert isinstance(m.matched_segments[2], WhitespaceSegment)
# Check the second Indent does not appear
assert not isinstance(m.matched_segments[3], Indent)
assert isinstance(m.matched_segments[3], KeywordSegment)
def test__parser__grammar_oneof_exclude(seg_list):
"""Test the OneOf grammar exclude option."""
fs = KeywordSegment.make("foo")
bs = KeywordSegment.make("bar")
g = OneOf(bs, exclude=Sequence(bs, fs))
with RootParseContext(dialect=None) as ctx:
# Just against the first alone
assert g.match(seg_list[:1], parse_context=ctx)
# Now with the bit to exclude included
assert not g.match(seg_list, parse_context=ctx)
def test__parser__grammar__base__longest_trimmed_match__adv(seg_list, caplog):
"""Test the _longest_trimmed_match method of the BaseGrammar."""
bs = StringParser("bar", KeywordSegment)
fs = StringParser("foo", KeywordSegment)
matchers = [
bs,
fs,
Sequence(bs, fs), # This should be the winner.
OneOf(bs, fs),
Sequence(bs, fs), # Another to check we return the first
]
with RootParseContext(dialect=None) as ctx:
# Matching the first element of the list
with caplog.at_level(logging.DEBUG, logger="sqluff.parser"):
match, matcher = BaseGrammar._longest_trimmed_match(seg_list, matchers, ctx)
# Check we got a match
assert match
# Check we got the right one.
assert matcher is matchers[2]
# And it matched the first three segments
assert len(match) == 3
def test__parser__grammar_sequence_indent(seg_list, caplog):
"""Test the Sequence grammar with indents."""
bs = StringParser("bar", KeywordSegment)
fs = StringParser("foo", KeywordSegment)
g = Sequence(Indent, bs, fs)
with RootParseContext(dialect=None) as ctx:
with caplog.at_level(logging.DEBUG, logger="sqlfluff.parser"):
m = g.match(seg_list, parse_context=ctx)
assert m
# check we get an indent.
assert isinstance(m.matched_segments[0], Indent)
assert isinstance(m.matched_segments[1], KeywordSegment)
def test__parser__grammar_sequence(seg_list, caplog):
"""Test the Sequence grammar."""
fs = KeywordSegment.make("foo")
bs = KeywordSegment.make("bar")
g = Sequence(bs, fs)
gc = Sequence(bs, fs, allow_gaps=False)
with RootParseContext(dialect=None) as ctx:
with caplog.at_level(logging.DEBUG, logger="sqlfluff.parser"):
# Should be able to match the list using the normal matcher
logging.info("#### TEST 1")
m = g.match(seg_list, parse_context=ctx)
assert m
assert len(m) == 3
assert m.matched_segments == (
bs("bar", seg_list[0].pos_marker),
seg_list[1], # This will be the whitespace segment
fs("foo", seg_list[2].pos_marker),
)
# Shouldn't with the allow_gaps matcher
logging.info("#### TEST 2")
assert not gc.match(seg_list, parse_context=ctx)
# Shouldn't match even on the normal one if we don't start at the beginning
logging.info("#### TEST 2")
assert not g.match(seg_list[1:], parse_context=ctx)