def string_sdv_from_fragments(fragments: Sequence[symbol_syntax.Fragment],
reference_restrictions: Optional[ReferenceRestrictions] = None,
) -> StringSdv:
if reference_restrictions is None:
reference_restrictions = _reference_restrictions.is_any_type_w_str_rendering()
return StringSdv(tuple([fragment_sdv_from_fragment(f, reference_restrictions)
for f in fragments]))
def string_sdv_of_single_symbol_reference(
symbol_name: str,
restrictions: ReferenceRestrictions = reference_restrictions.is_any_type_w_str_rendering(),
) -> StringSdv:
symbol_reference = SymbolReference(symbol_name,
restrictions)
fragments = [
string_sdvs.symbol_fragment(symbol_reference)
]
return StringSdv(tuple(fragments))
def visit_string(self, value: StringSdv) -> PathDdv:
string_ddv = value.resolve(self.symbols)
first_suffix_str = string_ddv.value_when_no_dir_dependencies()
following_suffix_str = self.suffix_sdv.resolve(self.symbols).value()
path_str = first_suffix_str + following_suffix_str
path = pathlib.PurePosixPath(path_str)
if path.is_absolute():
return path_ddvs.absolute_file_name(path_str)
else:
return path_ddvs.of_rel_option(
self.default_relativity,
path_ddvs.constant_path_part(path_str))
def _apply(self,
put: unittest.TestCase,
value: StringSdv,
message_builder: asrt.MessageBuilder):
put.assertIsInstance(value, StringSdv)
equals_symbol_references__w_str_rendering(self.symbol_references).apply_with_message(put,
value.references,
'symbol references')
environment = PathResolvingEnvironmentPreOrPostSds(fake_tcds(),
self.symbols)
actual_resolved_prim_val = value.resolve_value_of_any_dependency(environment)
self.expected_resolved_primitive_value.apply_with_message(put, actual_resolved_prim_val,
'resolved primitive value')
def equals_string_sdv(expected: StringSdv,
symbols: SymbolTable = None) -> Assertion[SymbolDependentValue]:
if symbols is None:
symbols = symbol_table_with_values_matching_references(expected.references)
expected_resolved_value = expected.resolve(symbols)
def get_fragment_sdvs(x: StringSdv) -> Sequence[StringFragmentSdv]:
return x.fragments
return type_sdv_assertions.matches_sdv_of_string(
equals_symbol_references__w_str_rendering(expected.references),
equals_string_ddv(expected_resolved_value),
asrt.sub_component('fragment resolvers',
get_fragment_sdvs,
equals_string_fragments(
expected.fragments)),
symbols)
def string(self, sdv: StringSdv) -> str:
return sdv.resolve(self._symbols).value_of_any_dependency(self._tcds)
def sdv_with_references(symbol_references: List[SymbolReference]) -> StringSdv:
fragment_sdvs = tuple([
string_sdvs.symbol_fragment(sym_ref) for sym_ref in symbol_references
])
return StringSdv(fragment_sdvs)
def visit_string(self, value: StringSdv) -> ResolvedValuePresentationBlock:
return _BlockForCustomRenderer(_StringRenderer(value.resolve(self.symbols).describer()))
def string_sdv_from_fragments(fragments: List[Fragment]) -> StringSdv:
fragment_resolves = [fragment_sdv_from_fragment(f) for f in fragments]
return StringSdv(tuple(fragment_resolves))
def from_fragments(fragments: Iterable[StringFragmentSdv]) -> StringSdv:
return StringSdv(tuple(fragments))
def from_list_sdv(list_sdv: ListSdv) -> StringSdv:
return StringSdv((list_fragment(list_sdv),))
def from_path_sdv(path: PathSdv) -> StringSdv:
return StringSdv((path_fragment(path),))
def symbol_reference(symbol_ref: SymbolReference) -> StringSdv:
return StringSdv((symbol_fragment(symbol_ref),))
def str_constant(string: str) -> StringSdv:
return StringSdv((str_fragment(string),))
def resolve_entry(
file_name: StringSdv, matcher: Optional[FileMatcherSdv]
) -> Tuple[StringDdv, Optional[FileMatcherDdv]]:
return file_name.resolve(symbols), map_optional(
resolve_matcher, matcher)