def parse_from_source(self,
source: ParseSource,
must_be_on_current_line: bool = True) -> AssertPhaseInstruction:
with token_stream_parser.from_parse_source(
source,
consume_last_line_if_is_at_eof_after_parse=True) as token_parser:
assert isinstance(token_parser,
token_stream_parser.TokenParser), 'Must have a TokenParser' # Type info for IDE
token_parser = token_parser_with_additional_error_message_format_map(token_parser,
self.format_map)
if must_be_on_current_line:
token_parser.require_is_not_at_eol('Missing {PATH} argument')
path_to_check = parse_file_ref.parse_file_ref_from_token_parser(config.ACTUAL_RELATIVITY_CONFIGURATION,
token_parser)
actual_path_checker_assertion_part = self._actual_path_checker_assertion_part(path_to_check)
files_matcher_resolver = parse_files_matcher.parse_files_matcher(token_parser,
must_be_on_current_line=False)
token_parser.report_superfluous_arguments_if_not_at_eol()
token_parser.consume_current_line_as_string_of_remaining_part_of_current_line()
assertions = assertion_part.compose(
actual_path_checker_assertion_part,
impl_utils.FilesMatcherAsDirContentsAssertionPart(files_matcher_resolver),
)
return assertion_part.AssertionInstructionFromAssertionPart(assertions,
None,
lambda x: FilesSource(path_to_check))
def parse_from_source(self, source: ParseSource) -> AssertPhaseInstruction:
with token_stream_parser.from_parse_source(
source,
consume_last_line_if_is_at_eof_after_parse=True) as token_parser:
assert isinstance(token_parser,
token_stream_parser.TokenParser), 'Must have a TokenParser' # Type info for IDE
return self._parse(token_parser)
def parse_from_source(self, source: ParseSource) -> AssertPhaseInstruction:
with token_stream_parser.from_parse_source(
source, consume_last_line_if_is_at_eof_after_parse=True
) as token_parser:
assert isinstance(token_parser, token_stream_parser.TokenParser
), 'Must have a TokenParser' # Type info for IDE
return self._parse(token_parser)
def parse(
self,
source: ParseSource,
source_file_location: Optional[pathlib.Path] = None,
):
with token_stream_parser.from_parse_source(source) as token_parser:
return self.parse_from_token_parser(token_parser,
source_file_location)
def parse_from_parse_source(source: ParseSource,
conf: RelOptionArgumentConfiguration = CONFIGURATION) -> StringOrFileRefResolver:
with from_parse_source(source,
consume_last_line_if_is_at_eol_after_parse=False) as token_parser:
ret_val = parse_from_token_parser(token_parser, conf)
if ret_val.source_type is SourceType.HERE_DOC:
if source.is_at_eol:
source.consume_current_line()
return ret_val
def parse(self, fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> AssertPhaseInstruction:
with token_stream_parser.from_parse_source(
source, consume_last_line_if_is_at_eol_after_parse=True
) as token_parser:
object_name, model_getter = self._parse_setup(token_parser)
int_matcher = self._matcher_parser.parse_from_token_parser(
token_parser)
token_parser.report_superfluous_arguments_if_not_at_eol()
return _instruction(object_name, int_matcher, model_getter)
def parse_from_source(self, source: ParseSource) -> SetupPhaseInstruction:
with from_parse_source(source,
consume_last_line_if_is_at_eof_after_parse=True
) as token_parser:
token_parser.consume_mandatory_constant_string_that_must_be_unquoted_and_equal(
[instruction_arguments.ASSIGNMENT_OPERATOR], lambda x: x)
string_source = self._str_src_parser.parse_from_token_parser(
token_parser)
token_parser.report_superfluous_arguments_if_not_at_eol()
token_parser.consume_current_line_as_string_of_remaining_part_of_current_line(
)
return _Instruction(string_source)
def _check_parse_from_token_parser(
put: unittest.TestCase, source: ParseSource,
expected_parsed_value: int,
expected_source_after_parse: Assertion[ParseSource]):
with token_stream_parser.from_parse_source(source, False,
False) as token_parser:
# ACT #
actual = _SUT_PARSER_OF_INT.parse_from_token_parser(token_parser)
# ASSERT #
put.assertEqual(expected_parsed_value, actual, 'parsed value')
expected_source_after_parse.apply_with_message(
put,
source,
'source',
)
def _parse(self, source: ParseSource) -> embryo.InstructionEmbryo:
first_line_number = source.current_line_number
with from_parse_source(source,
consume_last_line_if_is_at_eol_after_parse=True) as parser:
assert isinstance(parser, TokenParser) # Type info for IDE
path_to_create = parse_file_ref.parse_file_ref_from_token_parser(REL_OPT_ARG_CONF, parser)
instruction_config = InstructionConfig(
InstructionSourceInfo(first_line_number,
self._instruction_name),
_src_rel_opt_arg_conf_for_phase(self._phase_is_after_act),
CONTENTS_ARGUMENT
)
file_maker = parse_file_contents(instruction_config, parser)
return TheInstructionEmbryo(path_to_create, file_maker)
def check__abs_stx__expr_parse_source_variants(
self,
put: unittest.TestCase,
syntax: AbstractSyntax,
symbols: Optional[SymbolTable],
expectation: Expectation[T],
sub_test_identifiers: Mapping[str, Any] = MappingProxyType({}),
):
if symbols is None:
symbols = SymbolTable.empty()
for formatting_case in abs_stx_utils.formatting_cases(syntax):
for equivalent_source_case in equivalent_source_variants.expr_parse__s__nsc(
formatting_case.value):
with put.subTest(
zz_formatting=formatting_case.name,
zz_following_source_variant=equivalent_source_case.
name,
**sub_test_identifiers):
parse_source = equivalent_source_case.source
with token_stream_parser.from_parse_source(
parse_source) as token_parser:
# ACT
sdv = self._parser.parse(token_parser)
# ASSERT #
equivalent_source_case.expectation.apply_with_message(
put,
parse_source,
'source after parse',
)
expectation.symbol_references.apply_with_message(
put,
sdv.references,
'symbol references',
)
expectation.sdv.apply_with_message(
put, sdv, 'custom sdv expectation')
# ACT #
ddv = sdv.resolve(symbols)
# ASSERT #
expectation.ddv.apply_with_message(
put,
ddv,
'ddv',
)
def test_failing_parse(self):
cases = [
(
'no arguments',
remaining_source(''),
),
(
'no arguments, but it appears on the following line',
remaining_source('',
[comparators.EQ.name + ' 1']),
),
(
'invalid OPERATOR',
remaining_source('- 72'),
),
(
'quoted OPERATOR',
remaining_source('"{op}" 69'.format(op=comparators.EQ.name)),
),
(
'missing INTEGER',
remaining_source(comparators.EQ.name),
),
(
'missing INTEGER, but it appears on following line',
remaining_source(comparators.EQ.name,
['72']),
),
(
'invalid INTEGER',
remaining_source(comparators.EQ.name + ' 0.5'),
),
(
'invalid INTEGER expression',
remaining_source(comparators.EQ.name + ' "1 + [50]"'),
),
]
for name, source in cases:
with self.subTest(case_name=name):
with self.assertRaises(SingleInstructionInvalidArgumentException):
with from_parse_source(source) as parser:
sut.parse_integer_matcher(parser)
def parse_from_source(
self,
source: ParseSource,
must_be_on_current_line: bool = True) -> AssertPhaseInstruction:
with token_stream_parser.from_parse_source(
source, consume_last_line_if_is_at_eof_after_parse=True
) as token_parser:
token_parser = token_parser_with_additional_error_message_format_map(
token_parser, self.format_map)
if must_be_on_current_line:
token_parser.require_is_not_at_eol('Missing {PATH} argument')
path_to_check = self._path_parser.parse_from_token_parser(
token_parser)
token_parser.consume_mandatory_constant_unquoted_string(
reserved_words.COLON, must_be_on_current_line=False)
files_matcher_model_constructor = parse_file_matcher.DIR_CONTENTS_MODEL_PARSER.parse(
token_parser)
actual_path_checker_assertion_part = self._actual_path_checker_assertion_part(
path_to_check)
files_matcher_sdv = parse_files_matcher.parsers(
).full.parse_from_token_parser(token_parser)
token_parser.report_superfluous_arguments_if_not_at_eol()
token_parser.consume_current_line_as_string_of_remaining_part_of_current_line(
)
assertions = assertion_part.compose(
actual_path_checker_assertion_part,
impl_utils.FilesMatcherAsDirContentsAssertionPart(
files_matcher_model_constructor, files_matcher_sdv),
)
return assertion_part.AssertionInstructionFromAssertionPart(
assertions, lambda x: FilesSource(path_to_check))
def parse(self,
fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> TheInstructionEmbryo:
first_line_number = source.current_line_number
instruction_name_prefix = source.current_line_text[:source.column_index]
remaining_source_before = source.remaining_source
with from_parse_source(source,
consume_last_line_if_is_at_eol_after_parse=True,
consume_last_line_if_is_at_eof_after_parse=True) as token_parser:
symbol_name, value_resolver = _parse(fs_location_info, token_parser)
remaining_source_after = source.remaining_source
num_chars_consumed = len(remaining_source_before) - len(remaining_source_after)
parsed_str = remaining_source_before[:num_chars_consumed]
source_lines = LineSequence(first_line_number,
(instruction_name_prefix + parsed_str).splitlines())
source_info = fs_location_info.current_source_file.source_location_info_for(source_lines)
sym_def = SymbolDefinition(symbol_name,
SymbolContainer(value_resolver,
source_info))
return TheInstructionEmbryo(sym_def)
def _parse(self, source: ParseSource) -> _TheInstructionEmbryo:
with from_parse_source(
source,
consume_last_line_if_is_at_eol_after_parse=True) as tokens:
return self._parse_from_tokens(tokens)
def parse_list(source: ParseSource) -> ListSdv:
with from_parse_source(source) as token_parser:
return parse_list_from_token_parser(token_parser)
def parse(self, source: ParseSource) -> PARSE_RESULT:
with from_parse_source(source,
self._consume_last_line_if_is_at_eol_after_parse,
self._consume_last_line_if_is_at_eof_after_parse) as parser:
return self.parse_from_token_parser(parser)
def parse_list(source: ParseSource) -> ListResolver:
with from_parse_source(source) as token_parser:
return parse_list_from_token_parser(token_parser)
def parse_from_parse_source(grammar: Grammar,
source: ParseSource):
with token_stream_parser.from_parse_source(source) as tp:
return parse(grammar, tp)
def parse(self, source: ParseSource) -> PARSE_RESULT:
with from_parse_source(
source, self._consume_last_line_if_is_at_eol_after_parse,
self._consume_last_line_if_is_at_eof_after_parse) as parser:
return self.parse_from_token_parser(parser)
def parse_from_source(self, source: ParseSource) -> AssertPhaseInstruction:
with from_parse_source(source,
consume_last_line_if_is_at_eol_after_parse=True) as parser:
return self.parse_from_token_parser(parser)
def _parse(self, source: ParseSource) -> InstructionEmbryo[T]:
with token_stream_parser.from_parse_source(
source, consume_last_line_if_is_at_eol_after_parse=True
) as token_parser:
return self._parse_from_tokens(token_parser)
def parse(source: ParseSource) -> NameAndValue[Actor]:
with token_stream_parser.from_parse_source(
source,
consume_last_line_if_is_at_eol_after_parse=True) as token_parser:
return _parse_from_token_parser(token_parser)
def parse_from_source(self, source: ParseSource) -> AssertPhaseInstruction:
with from_parse_source(
source,
consume_last_line_if_is_at_eol_after_parse=True) as parser:
return self.parse_from_token_parser(parser)
def test_successful_parse(self):
# ARRANGE #
cases = [
Case(comparators.EQ.name + ' plain integer',
remaining_source(comparators.EQ.name + ' 1'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.EQ, 1),
[
model_of(-1),
model_of(1),
model_of(2),
])),
Case(comparators.NE.name,
remaining_source(comparators.NE.name + ' 1'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.NE, 1),
[
model_of(-1),
model_of(1),
model_of(2),
])),
Case(comparators.LT.name,
remaining_source(comparators.LT.name + ' 69'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.LT, 69),
[
model_of(60),
model_of(69),
model_of(72),
])),
Case(comparators.LTE.name,
remaining_source(comparators.LTE.name + ' 69'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.LTE, 69),
[
model_of(60),
model_of(69),
model_of(72),
])),
Case(comparators.GT.name,
remaining_source(comparators.GT.name + ' 69'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.GT, 69),
[
model_of(60),
model_of(69),
model_of(72),
])),
Case(comparators.GTE.name,
remaining_source(comparators.GTE.name + ' 69'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.GTE, 69),
[
model_of(60),
model_of(69),
model_of(72),
])),
Case(comparators.GTE.name + ' following content on line',
remaining_source(comparators.GTE.name + ' 72 next'),
source_assertion=
assert_source(remaining_part_of_current_line=asrt.equals('next')),
result_assertion=is_equivalent_to(matcher_of(comparators.GTE, 72),
[
model_of(69),
model_of(72),
model_of(80),
])),
Case(comparators.EQ.name + ' integer expression',
remaining_source('== "69+72"'),
source_assertion=
assert_source(is_at_eol=asrt.is_true),
result_assertion=is_equivalent_to(matcher_of(comparators.EQ, 69 + 72),
[
model_of(69 + 72 - 1),
model_of(69 + 72),
model_of(69 + 72 + 1),
])),
]
for case in cases:
with from_parse_source(case.source) as parser:
# ACT #
actual = sut.parse_integer_matcher(parser, _NAME_OF_LHS)
# ASSERT #
case.source_assertion.apply_with_message(self, case.source, 'source')
case.result_assertion.apply_with_message(self, actual, 'parsed value')