def test_not_matches(self):
# ARRANGE #
expected_instruction = Instruction()
expected_description = 'the description'
instruction_info = InstructionInfo(expected_instruction, expected_description)
expected_source = LineSequence(1, ('expected',))
actual_element = ParsedInstruction(expected_source, instruction_info)
cases = [
NameAndValue('mismatch on source',
sut.matches_instruction(asrt.not_(equals_line_sequence(expected_source)),
matches_instruction_info(asrt.equals(expected_description),
asrt.is_(expected_instruction)))
),
NameAndValue('mismatch on description',
sut.matches_instruction(equals_line_sequence(expected_source),
matches_instruction_info(asrt.not_(asrt.equals(expected_description)),
asrt.is_(expected_instruction)))
),
NameAndValue('mismatch on instruction',
sut.matches_instruction(equals_line_sequence(expected_source),
matches_instruction_info(asrt.not_(asrt.equals(expected_description)),
asrt.not_(asrt.is_(expected_instruction))))
),
]
for nav in cases:
with self.subTest(nav.name):
# ACT & ASSERT #
assert_that_assertion_fails(nav.value, actual_element)
def parse(self,
fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> Optional[ParsedSectionElement]:
current_line = source.current_line_text
if current_line == UNRECOGNIZED_ELEMENT_THAT_CAUSES_RETURN_VALUE_OF_NONE:
return None
consumed_source = consume_current_line_and_return_it_as_line_sequence(source)
if current_line.isspace():
return new_empty_element(consumed_source)
current_line_parts = current_line.split()
if current_line_parts[0] == INCLUDE_DIRECTIVE_NAME:
paths_to_include = [
pathlib.Path(file_name)
for file_name in current_line_parts[1:]
]
return ParsedFileInclusionDirective(consumed_source, paths_to_include)
elif current_line_parts[0] == SYNTAX_ERROR_INSTRUCTION_NAME:
raise RecognizedSectionElementSourceError(consumed_source, current_line_parts[1])
elif current_line_parts[0] == OK_INSTRUCTION_NAME:
return ParsedInstruction(consumed_source,
InstructionInfo(
InstructionInSectionWithParseSourceInfo(
self._section_name_to_register_in_instructions,
fs_location_info)))
else:
raise ValueError('Unknown source: ' + current_line)
def new_instruction(self,
source: LineSequence,
instruction: Instruction,
description: str = None) -> SectionContentElement:
return self._new(ElementType.INSTRUCTION,
source,
InstructionInfo(instruction,
description))
def parse(self, fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> ParsedInstruction:
current_line = source.current_line
source.consume_current_line()
instruction = ActPhaseInstructionThatRecords(
fs_location_info.current_source_file, current_line.text)
return ParsedInstruction(line_sequence_from_line(current_line),
InstructionInfo(instruction, None))
def test_matches(self):
# ARRANGE #
instruction = Instruction()
description = 'the description'
instruction_info = InstructionInfo(instruction, description)
actual_element = ParsedInstruction(LINE_SEQUENCE, instruction_info)
assertion = sut.matches_instruction(equals_line_sequence(LINE_SEQUENCE),
matches_instruction_info(asrt.equals(description),
asrt.is_(instruction)))
# ACT & ASSERT #
assertion.apply_without_message(self, actual_element)
def parse(self, fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> sut.ParsedInstruction:
first_line_number = source.current_line_number
dummy_source = line_source.LineSequence(first_line_number,
(source.current_line_text, ))
is_instruction = False
while not source.is_at_eof and source.current_line_text.startswith(
self.instruction_line_identifier):
source.consume_current_line()
is_instruction = True
if not is_instruction:
raise ValueError('Not an instruction')
return sut.ParsedInstruction(dummy_source,
InstructionInfo(Instruction(), None))
def parse(self, fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> ParsedSectionElement:
current_line = source.current_line_text
if current_line == '':
return new_empty_element(
consume_current_line_and_return_it_as_line_sequence(source))
elif is_comment_line(current_line):
return new_comment_element(
consume_current_line_and_return_it_as_line_sequence(source))
else:
instruction_source = self._consume_instruction_source(source)
return ParsedInstruction(
instruction_source,
InstructionInfo(InstructionInSection(self._section_name)))
def parse_and_compute_source(parser: InstructionParser,
fs_location_info: FileSystemLocationInfo,
source: ParseSource,
description: str = None) -> ParsedInstruction:
source_before = source.remaining_source
first_line_number = source.current_line_number
len_before_parse = len(source_before)
instruction = parser.parse(fs_location_info, source)
len_after_parse = len(source.remaining_source)
len_instruction_source = len_before_parse - len_after_parse
instruction_source = source_before[:len_instruction_source]
lines = instruction_source.split('\n')
if len(lines) > 1 and lines[-1] == '':
del lines[-1]
source = line_source.LineSequence(first_line_number, tuple(lines))
return ParsedInstruction(source, InstructionInfo(instruction, description))
def parse(self, fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> ParsedInstruction:
first_line_number = source.current_line_number
current_line = source.current_line_text
lines_read = [_un_escape(current_line)]
source.consume_current_line()
while not source.is_at_eof:
current_line = source.current_line_text
if syntax.is_section_header_line(current_line):
break
else:
lines_read.append(_un_escape(current_line))
source.consume_current_line()
line_sequence = LineSequence(first_line_number, tuple(lines_read))
return ParsedInstruction(
line_sequence,
InstructionInfo(SourceCodeInstruction(line_sequence), None))
def test_element_from_instruction_parser_SHOULD_be_assigned_to_section_contents_element(
self):
expected_instruction_info = InstructionInfo(Instruction(),
'description')
expected = sut.ParsedInstruction(
line_source.LineSequence(1, ('first line text', )),
expected_instruction_info)
parser = sut.standard_syntax_element_parser(
_InstructionParserThatGivesConstant(expected))
source = _source_for_lines(['ignored', 'source', 'lines'])
# ACT #
element = parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
# ASSERT #
element_assertion = matches_instruction(
source=asrt.is_(expected.source),
instruction_info=matches_instruction_info(
assertion_on_description=asrt.is_(
expected_instruction_info.description),
assertion_on_instruction=asrt.is_(
expected_instruction_info.instruction)))
element_assertion.apply_with_message(self, element, 'element')
def test_file_inclusion_directive(self):
self._check(sut.ParsedFileInclusionDirective(LINE_SEQUENCE, []),
sut.ParsedFileInclusionDirective)
def test_visit_SHOULD_raise_TypeError_WHEN_argument_is_not_a_sub_class_of_argument(
self):
visitor = ArgumentRecordingArgumentVisitor()
with self.assertRaises(TypeError):
visitor.visit(UnknownParsedSectionElementSubClass(LINE_SEQUENCE))
def _check(self, x: sut.ParsedSectionElement, expected_class):
# ARRANGE #
visitor = ArgumentRecordingArgumentVisitor()
# ACT #
returned = visitor.visit(x)
# ASSERT #
self.assertListEqual([expected_class], visitor.visited_classes)
self.assertIs(
x, returned,
'Visitor should return the return-value of the visited method')
class UnknownParsedSectionElementSubClass(sut.ParsedSectionElement):
def __init__(self, source: line_source.LineSequence):
super().__init__(source)
LINE_SEQUENCE = line_source.LineSequence(1, ('line text', ))
INSTRUCTION_INFO = InstructionInfo(Instruction(), 'description')