def __init__(self):
self._parser_of_lines_selection = _parse_options.OptionalOptionWMandatoryArgumentParser(
names.LINES_SELECTION_OPTION_NAME,
parse_line_matcher.parsers(must_be_on_current_line=False).simple,
)
self._parser_of_regex = parse_regex.ParserOfRegex()
self._parser_of_replacement = parse_string.StringFromTokensParser(_PARSE_REPLACEMENT_CONFIGURATION)
def test_resolving_object_with_different_symbol_values_SHOULD_give_different_values(self):
# ARRANGE #
STRING_SYMBOL_NAME = 'STRING_SYMBOL'
single_sym_ref_source = remaining_source(symbol_reference_syntax_for_name(STRING_SYMBOL_NAME))
parser = sut.ParserOfRegex()
# ACT #
actual_sdv = parser.parse_from_token_parser(single_sym_ref_source)
non_matching_string = '0'
for symbol_value in ['A', 'B']:
with self.subTest(symbol_value=symbol_value):
string_symbol = StringSymbolContext.of_constant(STRING_SYMBOL_NAME, symbol_value)
symbols = string_symbol.symbol_table
# ASSERT #
self._assert_resolved_pattern_has_pattern_string(
actual_sdv,
expected_pattern_string=symbol_value,
matching_string=symbol_value,
non_matching_string=non_matching_string,
symbols=symbols,
)
def _check(put: unittest.TestCase,
source: TokenParser,
arrangement: Arrangement,
expectation: Expectation):
# ARRANGE #
parser = sut.ParserOfRegex()
tcds = fake_tcds()
# ACT #
actual_sdv = parser.parse_from_token_parser(source)
# ASSERT #
expectation.token_stream.apply_with_message(put,
source.token_stream,
'token stream')
sdv_assertion = expectation.matches_regex_sdv(arrangement.symbols, tcds)
sdv_assertion.apply_with_message(put,
actual_sdv,
'sdv')
def test_failing_parse(self):
cases = [
NameAndValue(
'no arguments',
Arguments(''),
),
NameAndValue(
'invalid quoting of string',
Arguments('"missing end quote'),
),
]
parser = sut.ParserOfRegex()
for source_case in cases:
for option in OPTION_CASES:
arguments = source_case.value.prepend_to_first_line(option)
with self.subTest(case_name=source_case.name,
option=option):
source = remaining_source_lines(arguments.lines)
with self.assertRaises(SingleInstructionInvalidArgumentException):
parser.parse_from_token_parser(source)
return sdv.glob_pattern_sdv__str(property_getter,
glob_pattern.parse(token_parser))
return _parser(
parse_matcher_of_regex,
parse_matcher_of_glob_pattern,
)
def _parser(
parse_matcher_of_regex: Callable[[TokenParser], FileMatcherSdv],
parse_matcher_of_glob_pattern: Callable[[TokenParser], FileMatcherSdv],
) -> ParserFromTokens[FileMatcherSdv]:
return token_stream_parsing.ParserOfMandatoryChoiceWithDefault(
_SYNTAX_ELEM_STR,
[
token_stream_parsing.TokenSyntaxSetup(
token_matchers.is_unquoted_and_equals(
defs.REG_EX_OPERATOR.name),
parse_matcher_of_regex,
),
],
parse_matcher_of_glob_pattern,
)
_REGEX_PARSER = parse_regex.ParserOfRegex()
_SYNTAX_ELEM_STR = cl_syntax.cl_syntax_for_args(
(defs.GLOB_OR_REGEX__ARG_USAGE, ))
from exactly_lib.type_val_deps.types.string_matcher import StringMatcherSdv
from exactly_lib.util.cli_syntax import option_syntax
from exactly_lib.util.cli_syntax.elements import argument as a
from exactly_lib.util.textformat.structure.core import ParagraphItem
from exactly_lib.util.textformat.textformat_parser import TextParser
def parse(token_parser: TokenParser) -> StringMatcherSdv:
is_full_match = token_parser.consume_and_handle_optional_option(
False, lambda parser: True, matcher_options.FULL_MATCH_ARGUMENT_OPTION)
regex_sdv = _PARSER_OF_REGEX.parse_from_token_parser(token_parser)
return matches.sdv(is_full_match, regex_sdv)
_PARSER_OF_REGEX = parse_regex.ParserOfRegex()
class Description(grammar.PrimitiveDescriptionWithNameAsInitialSyntaxToken):
ARGUMENT_USAGE_LIST = (
a.Single(a.Multiplicity.OPTIONAL,
a.Option(matcher_options.FULL_MATCH_ARGUMENT_OPTION)),
syntax_elements.REGEX_SYNTAX_ELEMENT.single_mandatory,
)
@property
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
return self.ARGUMENT_USAGE_LIST
@property
def description_rest(self) -> Sequence[ParagraphItem]: