class _Describer(Generic[FILE_SPEC], DetailsRenderer):
EMPTY_RENDERER = details.String(' '.join((syntax.FILE_LIST_BEGIN, syntax.FILE_LIST_END)))
BEGIN_BRACE_RENDERER = details.String(syntax.FILE_LIST_BEGIN)
END_BRACE_RENDERER = details.String(syntax.FILE_LIST_END)
def __init__(self, files: Sequence[FILE_SPEC]):
self._files = files
def render(self) -> Sequence[Detail]:
return self._renderer().render()
def _renderer(self) -> DetailsRenderer:
return (
self.EMPTY_RENDERER
if len(self._files) == 0
else
self._renderer_of_non_empty()
)
def _renderer_of_non_empty(self) -> DetailsRenderer:
entries_renderer = details.SequenceRenderer([
file_spec.describer
for file_spec in self._files
])
return details.SequenceRenderer([
self.BEGIN_BRACE_RENDERER,
details.IndentedRenderer(entries_renderer),
self.END_BRACE_RENDERER,
])
def _trace_builder(self, actual: str) -> TraceBuilder:
ret_val = TraceBuilder(self.name)
ret_val.append_details(
custom_details.expected(details.String(repr(self._expected))))
ret_val.append_details(
custom_details.actual(details.String(repr(actual))))
return ret_val
def new_structure_builder_for(program: ToStringObject,
arguments: List[ToStringObject]) -> StructureBuilder:
return _structure_builder_w_argument_list(
CommandDriverForSystemProgram._NAME,
details.String(program),
arguments,
)
def __init__(self,
int_expression: StringDdv,
custom_integer_validator: Optional[CustomIntegerValidator] = None):
self._describer = details.String(strings.AsToStringObject(int_expression.describer()))
self._primitive_value_computer = _PrimitiveValueComputer(int_expression)
self._validator = _IntegerDdvValidator(self._primitive_value_computer,
custom_integer_validator)
def __init__(self, operator: ComparisonOperator):
self._config = comparison_matcher.IntModelConstructionConfig(
comparison_matcher.Config(
syntax_elements.INTEGER_SYNTAX_ELEMENT.singular_name,
operator,
lambda x: details.String(x),
))
def __init__(self,
lines_selector: Optional[LineMatcher],
preserve_new_lines: bool,
compiled_regular_expression: Pattern[str],
replacement: str,
):
super().__init__()
str_replacer = (
_StrReplacerExcludingNewLines(compiled_regular_expression,
replacement)
if preserve_new_lines
else
_StrReplacerIncludingNewLines(compiled_regular_expression,
replacement)
)
self._replacer_applier = (
_ReplacerApplierWoLineMatcherSelector(str_replacer)
if lines_selector is None
else
_ReplacerApplierWLineMatcherSelector(lines_selector, str_replacer)
)
self._structure_renderer = _StructureRendererForReplace(
lines_selector,
preserve_new_lines,
custom_details.PatternRenderer(compiled_regular_expression),
details.String(replacement),
)
def new_structure_builder_for(command_line: ToStringObject,
arguments: List[ToStringObject]) -> StructureBuilder:
ret_val = StructureBuilder(CommandDriverForShell.NAME).append_details(details.String(command_line))
if arguments:
ret_val.append_child(_ArgumentListRenderer(arguments))
return ret_val
def structure(self) -> StructureRenderer:
return _StructureRendererForReplace(
self._lines_selector,
self._preserve_new_lines,
self._regex.describer(),
details.String(strings.AsToStringObject(self._replacement.describer())),
)
def matches_w_trace(self, model: StringSource) -> MatchingResult:
actual = model.contents().as_str
if self.expected == actual:
return self._new_tb().build_result(True)
else:
err_msg = 'not eq to "{}": "{}"'.format(self.expected, actual)
return (self._new_tb().append_details(
details.String(err_msg)).build_result(False))
def _file(
path: Renderer[str],
mb_matcher: Optional[TSD],
) -> DetailsRenderer:
path_string = path.render()
return (details.String(path_string)
if mb_matcher is None else details.HeaderAndValue(
path_string, custom_details.WithTreeStructure(mb_matcher)))
def _result_for_exception(self, path: DescribedPath,
ex: Exception) -> MatchingResult:
tb = (self.__tb_with_expected().append_details(
details.HeaderAndValue(
types.PATH_TYPE_INFO.singular_name.capitalize(),
custom_details.PathDdvDetailsRenderer(
path.describer))).append_details(
details.HeaderAndValue('Error', details.String(ex))))
return tb.build_result(False)
def _result_for_unexpected_type(
self,
actual: Optional[file_properties.FileType]) -> MatchingResult:
actual_type_description = (
'unknown' if actual is None else
file_properties.TYPE_INFO[actual].description)
tb = self.__tb_with_expected().append_details(
custom_details.actual(details.String(actual_type_description)))
return tb.build_result(False)
def matches_w_trace(self, model: StringSource) -> MatchingResult:
first_line = self._first_line(model)
if first_line != '':
return (self._new_tb().append_details(
custom_details.actual(
details.String(repr(first_line) +
'...'))).build_result(False))
else:
return self._new_tb().build_result(True)
def __init__(self, file_type: file_properties.FileType):
super().__init__()
self._file_type = file_type
self._is_follow_sym_links = file_type is not file_properties.FileType.SYMLINK
self._renderer_of_expected_value = details.String(
file_properties.TYPE_INFO[self._file_type].description)
self._renderer_of_expected = custom_details.expected(
self._renderer_of_expected_value)
def render(self) -> Node[bool]:
file_spec_renderer = custom_details.HeaderAndValue(
NON_MATCHING_MATCHER,
details.String(self._non_matching_path)
)
return Node(self._name,
False,
file_spec_renderer.render(),
(self._non_match_result.trace.render(),)
)
def __init__(
self,
matcher: Callable[[MODEL, str], bool],
glob_pattern: str,
):
super().__init__()
self._matcher = matcher
self._glob_pattern = glob_pattern
self._renderer_of_expected = custom_details.expected(
details.String(str_constructor.Repr(glob_pattern)))
def _too_few_files(self) -> Tuple[str, DetailsRenderer]:
return (
common.NUM_FILES_LESS,
(
custom_details.string_list(self._consumed_file_names())
if self._fetch_of_expected_plus_1
else
details.String(common.NO_FILES__ACTUAL)
)
)
def __init__(
self,
is_ignore_case: bool,
string: StringDdv,
):
self._describer = custom_details.regex(
is_ignore_case,
details.String(
string_rendering.AsToStringObject(string.describer())))
self._validator = _ValidatorWhichCreatesRegex(is_ignore_case, string)
def _renderer(self) -> DetailsRenderer:
header_parts = [
_FORMATTED_FILE_TYPE_TOKENS[self._file_type], self._file_name
]
if self._contents_description is not None:
header_parts.append(
syntax.MODIFICATION_VARIANT_TOKENS[self._modification_type])
header = ' '.join(header_parts)
return (details.String(header) if
self._contents_description is None else details.HeaderAndValue(
header, self._contents_description))
def _all_match(self, tb: TraceBuilder,
tot_num_elements: int) -> MatchingResult:
actual = details.String(
str_constructor.FormatPositional(
'Every {} matches ({} tested)',
self._conf.setup.rendering.type_name,
tot_num_elements,
))
expected = custom_details.TreeStructure(
self._conf.predicate.structure())
return (tb.append_details(
custom_details.expected(expected)).append_details(
custom_details.actual(actual)).build_result(True))
def render(self) -> Node[bool]:
renderer = custom_details.ExpectedAndActual(
_expected_file_names_renderer(self._applier.files_condition),
custom_details.string_list(_files_in_model_list(self._actual)),
details.HeaderAndValue(
common.UNEXPECTED_NAME,
details.String(self._unexpected_file.relative_to_root_dir),
)
)
return Node(self._applier.name,
False,
renderer.render(),
(),
)
def _render(self) -> StructureRenderer:
ranges = [
(
repr(r)
if r == '' or r.isspace()
else
r
)
for r in [str(r) for r in self._ranges]
]
range_list = ' '.join(ranges)
return renderers.NodeRendererFromParts(
self._name,
None,
(details.String(range_list),),
(),
)
def render(self) -> Node[bool]:
get_explanation_and_actual = (
self._too_few_files
if len(self._fetch_of_expected_plus_1) < len(self._files_condition.files.keys())
else
self._too_many_files
)
explanation, actual = get_explanation_and_actual()
expected_and_actual = custom_details.ExpectedAndActual(
self._expected(),
actual,
details.String(explanation),
)
return Node(self._name,
False,
expected_and_actual.render(),
(),
)
def describer(self) -> DetailsRenderer:
return details.String(type(self))
def render(self) -> Sequence[Detail]:
renderer = details.String(option_syntax.option_syntax(self._option))
return renderer.render()
def _explanation_when_no_element_matcher_trace(
self, explanation: ToStringObject) -> DetailsRenderer:
return custom_details.ExpectedAndActual(
custom_details.TreeStructure(self._conf.predicate.structure()),
details.String(explanation),
)
def structure_for(self, arguments: ListDdv) -> StructureBuilder:
return commands.CommandDriverForExecutableFile.new_structure_builder_for(
details.String(
strings.AsToStringObject(self._exe_file.describer().value)),
_arguments_as_to_string_objects(arguments),
)
def _structure(self) -> StructureRenderer:
return self.new_structure_tree(
details.String(str_constructor.Repr(self._glob_pattern)))
def matches_w_trace(self, model: MODEL) -> MatchingResult:
tb = self._new_tb_with_expected().append_details(
custom_details.actual(
details.String(str_constructor.Repr(str(model)))))
return tb.build_result(self._matcher(model, self._glob_pattern))
def structure(self) -> StructureRenderer:
return MatchesGlobPattern.new_structure_tree(
details.String(
str_constructor.Repr(
string_rendering.AsToStringObject(
self._glob_pattern.describer()))))
