def check(self, environment: InstructionEnvironmentForPostSdsStep,
os_services: OsServices,
files_source: FilesSource) -> FilesSource:
path_to_check = (files_source.path_of_dir.resolve(
environment.symbols).value_of_any_dependency__d(environment.tcds))
helper = resolving_helper_for_instruction_env(os_services, environment)
model_constructor = self._resolve_model_constructor(
os_services, environment)
model = self._get_model(model_constructor, path_to_check)
matcher = helper.resolve_matcher(self._files_matcher)
try:
result = matcher.matches_w_trace(model)
if not result.value:
final_result = self._final_result_of(model_constructor, result)
raise pfh_ex_method.PfhFailException(
rend_comb.SequenceR([
path_err_msgs.line_header_block__primitive(
file_or_dir_contents_headers.
unexpected_of_file_type(FileType.DIRECTORY),
path_to_check.describer,
),
rendering__node_bool.BoolTraceRenderer(
final_result.trace),
]))
return files_source
except HardErrorException as ex:
raise pfh_ex_method.PfhHardErrorException(ex.error)
def plain_sequence(
line_renderers: Sequence[Renderer[LineObject]]
) -> SequenceRenderer[LineElement]:
return rend_comb.SequenceR([
comp_rend.LineElementR(line_renderer)
for line_renderer in line_renderers
])
def source_lines_in_section_block_renderer(
section_name: str,
source_lines: Sequence[str],
) -> SequenceRenderer[MinorBlock]:
return comb.SequenceR([
comp_rend.MinorBlockR(_InSectionNameRenderer(section_name)),
SourceLinesBlockRenderer(source_lines),
])
def _location_path_and_source_blocks(
source_location: Optional[SourceLocationPath]
) -> SequenceRenderer[MinorBlock]:
if source_location is None:
return comb.SequenceR([])
else:
referrer_location = pathlib.Path('.')
return SourceLocationPathRenderer(referrer_location, source_location)
def header_and_message(
single_line_header: Any,
message: SequenceRenderer[LineElement]) -> MinorTextRenderer:
return rend_comb.SequenceR([
blocks.MinorBlockOfSingleLineObject(
line_objects.StringLineObject(single_line_header), ),
comp_rend.MinorBlockR(message),
])
def stderr_contents_block(stderr_contents: str) -> Renderer[MinorBlock]:
if not stderr_contents:
stderr_contents = '<empty>'
return comp_rend.MinorBlockR(
combinators.SequenceR([
comp_rend.LineElementR(
line_objects.PreFormattedString(
texts.OUTPUT_ON_STDERR__HEADER)),
comp_rend.LineElementR(
line_objects.PreFormattedString.of_str(stderr_contents)),
]))
def _actual_exit_code_and_stderr_block(
exit_code: int, stderr_contents: str) -> Renderer[MajorBlock]:
def exit_code_block() -> Renderer[MinorBlock]:
return blocks.MinorBlockOfSingleLineObject(
line_objects.PreFormattedString(_actual_exit_code_line(exit_code)))
minor_blocks = [
exit_code_block(),
]
if stderr_contents:
minor_blocks.append(stderr_contents_block(stderr_contents))
return comp_rend.MajorBlockR(combinators.SequenceR(minor_blocks))
def _file_exists_but_must_also_satisfy_file_matcher(
self) -> pfh.PassOrFailOrHardError:
matching_result = self._matches_file_matcher_for_expectation_type()
if matching_result.value:
return pfh.new_pfh_pass()
else:
err_msg = rend_comb.SequenceR([
path_err_msgs.line_header_block__primitive(
str_constructor.FormatMap(
'Existing {PATH} does not satisfy {FILE_MATCHER}',
_EXISTING_PATH_FAILURE_FORMAT_MAP),
self.described_path.describer,
),
rendering__node_bool.BoolTraceRenderer(matching_result.trace),
])
return pfh.new_pfh_fail(err_msg)
def describer(self) -> SequenceRenderer[str]:
return rend_comb.SequenceR(
[element.describer() for element in self._string_elements])
def non_zero_exit_code_msg(program: StructureRenderer, exit_code: int,
stderr_contents: str) -> TextRenderer:
return combinators.SequenceR([
header_and_program_block(_NON_ZERO_EXIT_CODE_HEADER, program),
_actual_exit_code_and_stderr_block(exit_code, stderr_contents),
])
