def tail(self, model_getter: ModelGetter[ExitCodeAndStderrFile], model: ExitCodeAndStderrFile) -> TextRenderer:
stderr_contents = self._stderr_contents_str(model)
return rend_comb.SingletonSequenceR(
blocks.major_block_of_single_minor_block(
top_lvl_error_msg_rendering.stderr_contents_block(stderr_contents)
)
)
def render(self) -> MajorBlock:
renderer = comp_rend.MajorBlockR(
rend_comb.SingletonSequenceR(
comp_rend.MinorBlockR(
rendering.details_renderer_to_line_elements(
layout__node_wo_data.RENDERING_CONFIGURATION,
self._details.render()))))
return renderer.render()
def _validation_error(header: str, path: pathlib.Path) -> svh.SuccessOrValidationErrorOrHardError:
return svh.new_svh_validation_error(
rend_comb.SingletonSequenceR(
header_rendering.HeaderValueRenderer(
header,
text_docs.minor_blocks_of_string_lines([str(path)])
)
)
)
def head(self, model_getter: ModelGetter[ExitCodeAndStderrFile], model: ExitCodeAndStderrFile) -> TextRenderer:
return rend_comb.SingletonSequenceR(
header_rendering.HeaderValueRenderer.of_unexpected_attr_of_obj(
texts.ATTRIBUTE__EXIT_CODE,
self._object_name,
model_getter.description(),
'from',
)
)
def _err_msg(path: str,
header_tmpl: str) -> TextRenderer:
header = str_constructor.FormatMap(header_tmpl, _FORMAT_MAP)
return rend_comb.SingletonSequenceR(
header_blocks.w_details(
header,
text_docs.minor_blocks_of_string_lines([path])
)
)
def _failure_message(self,
model_getter: ModelGetter[MODEL],
model: MODEL,
result: MatchingResult,
) -> TextRenderer:
return rend_comb.ConcatenationR([
self._failure_message_config.head(model_getter, model),
rend_comb.SingletonSequenceR(rendering__node_bool.BoolTraceRenderer(result.trace)),
self._failure_message_config.tail(model_getter, model),
])
def description(self) -> SequenceRenderer[MinorBlock]:
path_ddv = path_ddvs.of_rel_option(
RelOptionType.REL_RESULT,
path_ddvs.constant_path_part(self._sds.result.exitcode_file.name),
)
described_path = path_ddv.value_of_any_dependency__d(self._tcds)
return rend_comb.SingletonSequenceR(
path_rendering.minor_block_renderer_of_primitive(
described_path.describer))
def visit_act_phase_failure(self, failure_info: ActPhaseFailureInfo) -> SequenceRenderer[MajorBlock]:
phase_source_and_actor = source_location.section_and_source(
failure_info.phase_step.phase.identifier,
rend_comb.PrependR(
self._actor_info_block(failure_info.actor_name),
source_location.source_str_renderer(failure_info.phase_source),
)
)
return rend_comb.SingletonSequenceR(
comp_rend.MajorBlockR(phase_source_and_actor)
)
def _check(self, environment: InstructionEnvironmentForPostSdsStep,
os_services: OsServices, model: StringSource):
resolver = resolving_helper_for_instruction_env(
os_services, environment)
string_matcher = resolver.resolve_matcher(self._string_matcher)
matching_result = self._apply_matcher(string_matcher, model)
if not matching_result.value:
raise pfh_exception.PfhFailException(
rend_comb.SingletonSequenceR(
rendering__node_bool.BoolTraceRenderer(
matching_result.trace)))
def source_str_renderer(source: str) -> SequenceRenderer[MinorBlock]:
return comb.SingletonSequenceR(
SourceLinesBlockRenderer(source.splitlines()))
def renderer(self) -> TextRenderer:
return rend_comb.SingletonSequenceR(
comp_rend.MajorBlockR(self._minor_blocks_renderer()))
def single_pre_formatted(s: str) -> MinorTextRenderer:
return rend_comb.SingletonSequenceR(
comp_rend.MinorBlockR(line_elements.single_pre_formatted(s)))
def location_blocks_renderer(
source_location: Optional[SourceLocationPath],
section_name: Optional[str],
description: Optional[str]) -> SequenceRenderer[MajorBlock]:
return comb.SingletonSequenceR(
location_block_renderer(source_location, section_name, description))
def major_blocks_of_string_lines(
lines: Sequence[str]) -> SequenceRenderer[MajorBlock]:
return rend_comb.SingletonSequenceR(
comp_rend.MajorBlockR(minor_blocks_of_string_lines(lines)))
def minor_blocks_of_string_lines(
lines: Sequence[str]) -> SequenceRenderer[MinorBlock]:
return rend_comb.SingletonSequenceR(
comp_rend.MinorBlockR(plain_line_elements_of_string_lines(lines)))
self.described_path)
return helper.apply(sdv, model)
def _file_matcher_for_expectation_type(self) -> FileMatcherSdv:
return (self.file_matcher if self._is_positive_check() else
combinator_sdvs.Negation(self.file_matcher))
def _is_positive_check(self) -> bool:
return self.expectation_type is ExpectationType.POSITIVE
_ERROR_MESSAGE_HEADER = 'Failure for path:'
_FILE_EXISTS_BUT_INVALID_PROPERTIES_ERR_MSG_HEADER = rend_comb.SingletonSequenceR(
rend_comb.ConstantR(
text_struct.LineElement(
text_struct.StringLineObject('File exists, but:'))))
_EXISTING_PATH_FAILURE_FORMAT_MAP = {
'PATH': syntax_elements.PATH_SYNTAX_ELEMENT.singular_name,
'FILE_MATCHER': syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.singular_name,
}
_PROPERTIES_DESCRIPTION = """\
Applies a {FILE_MATCHER} on {PATH}, if it exists.
"""
_NOTES = """\
Symbolic links are not followed in the test of existence
(so a broken symbolic link is considered to exist).
"""
def _single_path(path: pathlib.Path) -> SequenceRenderer[LineElement]:
return rend_comb.SingletonSequenceR(_of_path(path))
def major_blocks_of_string_blocks(contents: Blocks) -> SequenceRenderer[MajorBlock]:
return rend_comb.SingletonSequenceR(
major_block_of_string_blocks(contents)
)
