def __init__(self, phase_is_after_act: bool):
self._phase_is_after_act = phase_is_after_act
self._name_parser = parse_string.StringFromTokensParser(
parse_string.Configuration(defs.VAR_NAME_ELEMENT,
reference_restrictions.is_string__all_indirect_refs_are_strings())
)
self._value_parser = parse_str_src.default_parser_for(phase_is_after_act=self._phase_is_after_act)
self._unset_keyword_matcher = token_matchers.is_unquoted_and_equals(defs.UNSET_IDENTIFIER)
def test_fail_WHEN_restriction_is_of_other_type__multi(self):
# ARRANGE #
assertion_to_check = sut.is_reference_restrictions__value_type(
[ValueType.PATH, ValueType.PROGRAM])
restriction = reference_restrictions.is_string__all_indirect_refs_are_strings(
)
# ACT & ASSERT #
assert_that_assertion_fails(assertion_to_check, restriction)
def __init__(
self,
name: str,
value_int: int,
value_str: str,
):
self.name = name
self.value_int = value_int
self.value_str = value_str
self.ref_syntax = symbol_reference_syntax_for_name(name)
self.symbol_reference = SymbolReference(
name,
reference_restrictions.is_string__all_indirect_refs_are_strings())
def test_symbols_from_contents_assertion_SHOULD_be_reported(self):
# ARRANGE #
operand_sym_ref = SymbolReference('operand_symbol_name',
is_string__all_indirect_refs_are_strings())
condition_str = '{operator} {symbol_reference}'.format(
operator=comparators.EQ.name,
symbol_reference=symbol_reference_syntax_for_name(operand_sym_ref.name)
)
arguments_constructor = args.complete_arguments_constructor(
FileQuantificationAssertionVariant(
Quantifier.ALL,
file_contents_arg2(sm_arg.NumLines(condition_str))))
argument = arguments_constructor.apply(
expectation_type_config__non_is_success(ExpectationType.NEGATIVE)
)
source = remaining_source(argument)
# ACT #
matcher_sdv = sut.parsers().full.parse(source)
assert isinstance(matcher_sdv, MatcherSdv)
actual_symbol_references = matcher_sdv.references
# ASSERT #
expected_symbol_references = [
operand_sym_ref,
]
assertion = equals_symbol_references__w_str_rendering(expected_symbol_references)
assertion.apply_without_message(self, actual_symbol_references)
AccumulatedComponents.empty(),
)
class _ParseAsCommand(ParserFromTokenParserBase[CommandSdv]):
def __init__(self):
super().__init__(consume_last_line_if_is_at_eol_after_parse=False)
self._arguments_parser = parse_arguments.parser()
def parse_from_token_parser(self, parser: TokenParser) -> CommandSdv:
program_name = parse_string.parse_string_from_token_parser(
parser, _PARSE_NAME_CONF)
arguments = self._arguments_parser.parse_from_token_parser(parser)
return CommandSdv(CommandDriverSdvForSystemProgram(program_name),
arguments)
_PROGRAM_NAME_STRING_REFERENCES_RESTRICTION = is_string__all_indirect_refs_are_strings(
text_docs.single_pre_formatted_line_object(
str_constructor.FormatMap(
'A program name must be defined in terms of {string_type}.',
{
'string_type':
define_symbol.TYPE_W_STR_RENDERING_INFO_DICT[
WithStrRenderingType.STRING].identifier
},
)))
_PARSE_NAME_CONF = parse_string.Configuration(
'NAME', _PROGRAM_NAME_STRING_REFERENCES_RESTRICTION)
from exactly_lib.type_val_prims.files_source.files_source import FilesSource
from exactly_lib.util.description_tree import details
from exactly_lib.util.description_tree.renderer import DetailsRenderer
from exactly_lib.util.description_tree.tree import Detail
from exactly_lib.util.render import combinators as rend_comb
from exactly_lib.util.str_ import str_constructor
from exactly_lib.util.symbol_table import SymbolTable
from .. import syntax
from ..file_maker import FileMakerAdv, FileMakerDdv, FileMakerSdv, FileMaker
FILE_NAME_STRING_REFERENCES_RESTRICTION = reference_restrictions.is_string__all_indirect_refs_are_strings(
text_docs.single_pre_formatted_line_object(
str_constructor.FormatMap(
'A {file_name} must be defined in terms of {string_type}.',
{
'file_name': syntax.FILE_NAME.name,
'string_type': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name
},
)
)
)
class FileSpecification(WithDetailsDescription):
def __init__(self,
file_name: str,
file_maker: FileMaker,
):
self.name = file_name
self.maker = file_maker
_ARGUMENTS__LINE_NUMS = [
a.Single(a.Multiplicity.MANDATORY, names.LINE_NUMBERS_FILTER_OPTION),
a.Single(a.Multiplicity.ONE_OR_MORE, a.Named(names.RANGE_EXPR_SED_NAME))
]
_MATCHER_ARGUMENT = a.Named('MATCHER')
_RANGE_LIMIT_SEPARATOR = ':'
_RANGE_EXPR_REFERENCE_RESTRICTIONS = is_string__all_indirect_refs_are_strings(
text_docs.single_pre_formatted_line_object(
str_constructor.FormatMap(
'A {RANGE} must be made up of just {string_type} values.', {
'RANGE':
names.RANGE_EXPR_SED_NAME,
'string_type':
help_texts.ANY_TYPE_INFO_DICT[ValueType.STRING].identifier
})))
class SyntaxDescription(
grammar.PrimitiveDescriptionWithNameAsInitialSyntaxToken):
def __init__(self):
self._tp = TextParser({
'MATCHER':
_MATCHER_ARGUMENT.name,
'_LINE_MATCHER_':
syntax_elements.LINE_MATCHER_SYNTAX_ELEMENT.singular_name,
'FIRST_LINE_NUMBER':
def parse(self, token_parser: TokenParser) -> IntegerSdv:
string_sdv = self._string_parser.parse(token_parser)
return integer_sdv.IntegerSdv(string_sdv,
self._custom_integer_restriction)
def validator_for_non_negative(actual: int) -> Optional[TextRenderer]:
if actual < 0:
return expected_found.unexpected_lines(
_NON_NEGATIVE_INTEGER_ARGUMENT_DESCRIPTION, str(actual))
return None
_NON_NEGATIVE_INTEGER_ARGUMENT_DESCRIPTION = 'An integer >= 0'
_REFERENCE_RESTRICTIONS = is_string__all_indirect_refs_are_strings(
text_docs.single_pre_formatted_line_object(
str_constructor.FormatMap(
'The {INTEGER} argument must be made up of just {string_type} values.',
{
'INTEGER':
syntax_elements.INTEGER_SYNTAX_ELEMENT.argument.name,
'string_type':
help_texts.ANY_TYPE_INFO_DICT[ValueType.STRING].identifier
})))
_STRING_PARSER_CONFIGURATION = parse_string.Configuration(
syntax_elements.INTEGER_SYNTAX_ELEMENT.singular_name,
_REFERENCE_RESTRICTIONS,
)
from exactly_lib.symbol.sdv_structure import SymbolUsage, SymbolReference
from exactly_lib.type_val_deps.sym_ref.w_str_rend_restrictions.reference_restrictions import \
is_string__all_indirect_refs_are_strings
from exactly_lib_test.symbol.test_resources import symbol_usage_assertions as asrt_sym_usage
from exactly_lib_test.test_resources.value_assertions import value_assertion as asrt
from exactly_lib_test.test_resources.value_assertions.value_assertion import Assertion
from exactly_lib_test.type_val_deps.test_resources.w_str_rend import data_restrictions_assertions as asrt_rest
IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS = (
asrt_rest.equals__w_str_rendering(
is_string__all_indirect_refs_are_strings()))
def is_sym_ref_to_string__w_all_indirect_refs_are_strings__usage(
name_of_symbol: str) -> Assertion[SymbolUsage]:
return asrt_sym_usage.matches_reference(
asrt.equals(name_of_symbol),
IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS)
def is_sym_ref_to_string__w_all_indirect_refs_are_strings(
name_of_symbol: str, ) -> Assertion[SymbolReference]:
return asrt_sym_usage.matches_reference__ref(
asrt.equals(name_of_symbol),
IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS)
