def _invokation_variants_parentheses(self) -> List[InvokationVariant]:
arguments = [
a.Single(a.Multiplicity.MANDATORY, a.Constant('(')),
self.concept_argument,
a.Single(a.Multiplicity.MANDATORY, a.Constant(')')),
]
iv = invokation_variant_from_args(arguments)
return [iv]
def _constant_sed(name: str) -> SyntaxElementDescription:
return SyntaxElementDescription(name, _TP.fnap(_LITERAL__HEADER), [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, a.Constant(
syntax.LITERAL_BEGIN)),
a.Single(a.Multiplicity.ONE_OR_MORE, a.Named(_FILE_CONDITION)),
a.Single(a.Multiplicity.MANDATORY, a.Constant(syntax.LITERAL_END)),
], _TP.fnap(_LITERAL__DESCRIPTION_REST)),
])
def _common_initial_args__suite() -> List[arg.ArgumentUsage]:
return [
arg.Single(arg.Multiplicity.MANDATORY,
arg.Constant(common_opts.SYMBOL_COMMAND)),
arg.Single(arg.Multiplicity.MANDATORY,
arg.Constant(common_opts.SUITE_COMMAND)),
arg.Single(arg.Multiplicity.ZERO_OR_MORE, SUITE_OPTION_ARGUMENT),
arg.Single(arg.Multiplicity.MANDATORY,
instruction_arguments.FILE_ARGUMENT),
]
def _here_doc() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(
a.Multiplicity.MANDATORY,
a.Constant(string.HERE_DOCUMENT_MARKER_PREFIX +
_HERE_DOC_SYNTAX_MARKER)),
a.Single(a.Multiplicity.ZERO_OR_MORE, a.Named(_HERE_DOC_LINE)),
a.Single(a.Multiplicity.MANDATORY,
a.Constant(_HERE_DOC_SYNTAX_MARKER)),
], _TEXT_PARSER.fnap(_DESCRIPTION__HERE_DOC))
def invokation_variants(self) -> List[InvokationVariant]:
primitive_arg = a.single_mandatory(a.Named(self._primitive_name))
return [
invokation_variant_from_args([primitive_arg]),
invokation_variant_from_args([
a.single_mandatory(a.Constant('(')),
primitive_arg,
a.single_mandatory(a.Constant(')')),
]),
]
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
element_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(self._element_name)
)
separator_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(logic.QUANTIFICATION_SEPARATOR_ARGUMENT)
)
return (element_arg,
separator_arg,
self._element_matcher_syntax_info.single_mandatory,
)
def _file_list_sed(name: str) -> SyntaxElementDescription:
return SyntaxElementDescription(name, (), [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
a.Constant(syntax.FILE_LIST_BEGIN)),
a.Single(a.Multiplicity.ONE_OR_MORE,
a.Named(syntax.FILE_SPEC__SE_STR)),
a.Single(a.Multiplicity.MANDATORY, a.Constant(
syntax.FILE_LIST_END)),
], _TP.fnap(_FILE_LIST__DESCRIPTION_REST)),
])
def test_choice(self):
test_cases = [
sut.Choice.of_single_argument_choices(sut.Multiplicity.OPTIONAL,
[sut.Constant('constant')]),
sut.Choice.of_single_argument_choices(
sut.Multiplicity.OPTIONAL,
[sut.Constant('constant'),
sut.Named('name')]),
]
for value in test_cases:
with self.subTest():
str(value)
def def_instruction_arguments(self) -> List[a.ArgumentUsage]:
before_value = [
a.Single(a.Multiplicity.MANDATORY, a.Constant(self.identifier)),
_SYMBOL_NAME,
_EQUALS,
]
return before_value + self.value_arguments
def _sym_ref() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
a.Constant(pgm_syntax_elements.SYMBOL_REF_PROGRAM_TOKEN)),
a.Single(a.Multiplicity.MANDATORY,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument),
], _TEXT_PARSER.fnap(_SYM_REF_PROGRAM_DESCRIPTION))
def syntax(self) -> Sequence[a.ArgumentUsage]:
return [
a.single_mandatory(
a.Constant(instruction_names.SHELL_INSTRUCTION_NAME)),
a.single_mandatory(
syntax_elements.SHELL_COMMAND_LINE_SYNTAX_ELEMENT.argument)
]
def def_instruction_argument_syntax() -> List[a.ArgumentUsage]:
return [
a.Single(a.Multiplicity.MANDATORY, a.Named(TYPE_SYNTAX_ELEMENT)),
a.Single(a.Multiplicity.MANDATORY,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument),
a.Single(a.Multiplicity.MANDATORY, a.Constant(ASSIGNMENT_ARGUMENT)),
a.Single(a.Multiplicity.MANDATORY, a.Named(VALUE_SYNTAX_ELEMENT)),
]
def text_until_end_of_line() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(
a.Multiplicity.MANDATORY,
a.Constant(pgm_syntax_elements.
REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER)),
a.Single(a.Multiplicity.MANDATORY, TEXT_UNTIL_END_OF_LINE_ARGUMENT)
], _TEXT_PARSER.fnap(_TEXT_UNTIL_END_OF_LINE_DESCRIPTION))
def invokation_variant_of(
operator_name: str,
syntax: OperatorDescription) -> InvokationVariant:
operator_argument = a.Single(a.Multiplicity.MANDATORY,
a.Constant(operator_name))
all_arguments = [operator_argument, self.concept_argument]
return invokation_variant_from_args(all_arguments,
syntax.description_rest)
def test_constant_argument_should_produce_constant_string(self):
# ARRANGE #
renderer = sut.ArgumentOnCommandLineRenderer()
argument_usage = arg.Constant('the_constant')
# ACT #
actual = renderer.visit(argument_usage)
# ASSERT #
self.assertEqual('the_constant', actual)
def invokation_variants(self) -> Sequence[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
a.Constant(
instruction_arguments.ASSIGNMENT_OPERATOR)),
syntax_elements.STRING_SOURCE_SYNTAX_ELEMENT.single_mandatory,
]),
]
def __init__(self, name: str):
self.negation_argument = a.Constant(NEGATION_OPERATOR)
super().__init__(
name, {
'PATH': _PATH_ARGUMENT.name,
'FILE_MATCHER':
syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.singular_name,
'NEGATION_OPERATOR': NEGATION_OPERATOR,
'PASS': exit_values.EXECUTION__PASS.exit_identifier,
})
def _modification_args(self) -> List[a.ArgumentUsage]:
if self.modification is None:
return []
else:
return [
a.Single(
a.Multiplicity.MANDATORY,
a.Constant(
syntax.MODIFICATION_VARIANT_TOKENS[self.modification]))
]
def synopsis() -> cli_syntax.Synopsis:
command_line = arg.CommandLine([
arg.Single(arg.Multiplicity.MANDATORY,
arg.Constant(common_opts.SUITE_COMMAND)),
arg.Single(arg.Multiplicity.OPTIONAL, _REPORTER_OPTION),
arg.Single(arg.Multiplicity.OPTIONAL, _ACTOR_OPTION),
arg.Single(arg.Multiplicity.MANDATORY, _FILE_ARGUMENT),
],
prefix=program_info.PROGRAM_NAME)
return cli_syntax.Synopsis(command_line, _TP.text(_DESCRIPTION_PARAGRAPH))
def invokation_variants(self) -> Sequence[InvokationVariant]:
phase_spec_args = self._phase_spec_args()
name = a.Single(a.Multiplicity.MANDATORY,
a.Named(defs.VAR_NAME_ELEMENT))
value = a.Single(a.Multiplicity.MANDATORY,
a.Named(defs.VAR_VALUE_ELEMENT))
assignment = a.Single(a.Multiplicity.MANDATORY,
a.Constant(defs.ASSIGNMENT_IDENTIFIER))
unset_kw = a.Single(a.Multiplicity.MANDATORY,
a.Constant(defs.UNSET_IDENTIFIER))
return [
invokation_variant_from_args(
phase_spec_args + [name, assignment, value],
self._tp.fnap(_DESCRIPTION_OF_SET),
),
invokation_variant_from_args(
phase_spec_args + [unset_kw, name],
self._tp.fnap(_DESCRIPTION_OF_UNSET),
),
]
def system_program(arguments: List[a.ArgumentUsage]) -> InvokationVariant:
return invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
a.Constant(pgm_syntax_elements.SYSTEM_PROGRAM_TOKEN)
),
a.Single(a.Multiplicity.MANDATORY,
syntax_elements.STRING_SYNTAX_ELEMENT.argument
),
] + arguments,
_TEXT_PARSER.paras(misc_texts.SYSTEM_PROGRAM_DESCRIPTION)
)
def _file_condition_sed() -> SyntaxElementDescription:
return SyntaxElementDescription(
_FILE_CONDITION, _TP.fnap(_FILE_CONDITION_DESCRIPTION_REST), [
invokation_variant_from_args([
syntax.FILE_NAME__ARG,
]),
invokation_variant_from_args([
syntax.FILE_NAME__ARG,
a.Single(a.Multiplicity.MANDATORY,
a.Constant(syntax.FILE_MATCHER_SEPARATOR)),
syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.single_mandatory,
], _TP.fnap(_FILE_NAME_WITH_MATCHER_DESCRIPTION_REST)),
])
def optional_negation_argument_usage() -> a.ArgumentUsage:
return a.Single(a.Multiplicity.OPTIONAL,
a.Constant(logic.NOT_OPERATOR_NAME))
def _file_type_arg(self) -> a.ArgumentUsage:
return a.Single(a.Multiplicity.MANDATORY,
a.Constant(syntax.FILE_TYPE_TOKENS[self.file_type]))
from exactly_lib.definitions.test_case import reserved_words
from exactly_lib.util.cli_syntax.elements import argument as a
RESERVED_WORD__COLON = a.Single(a.Multiplicity.MANDATORY,
a.Constant(reserved_words.COLON))
return before_value + self.value_arguments
def _standard_type_value_args(
type_info: TypeNameAndCrossReferenceId,
value_multiplicity: a.Multiplicity = a.Multiplicity.MANDATORY
) -> List[a.ArgumentUsage]:
return [
a.Single(value_multiplicity, a.Named(type_info.syntax_element_name))
]
_SYMBOL_NAME = a.Single(a.Multiplicity.MANDATORY,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument)
_EQUALS = a.Single(a.Multiplicity.MANDATORY, a.Constant(ASSIGNMENT_ARGUMENT))
TYPE_W_STR_RENDERING_INFO_DICT: Mapping[
WithStrRenderingType, TypeInfo] = MappingProxyType({
WithStrRenderingType.STRING:
TypeInfo(
types.STRING_TYPE_INFO,
_standard_type_value_args(types.STRING_TYPE_INFO,
a.Multiplicity.MANDATORY)),
WithStrRenderingType.PATH:
TypeInfo(
types.PATH_TYPE_INFO,
path_syntax.mandatory_path_with_optional_relativity(
a.Named(types.PATH_TYPE_INFO.syntax_element_name),
PATH_SUFFIX_IS_REQUIRED)),
WithStrRenderingType.LIST:
FILE_TYPE_SE_STR = 'FILE-TYPE'
FILE_SPEC__SE_STR = 'FILE-SPEC'
REGULAR_FILE_TOKEN = instruction_names.NEW_FILE_INSTRUCTION_NAME
DIRECTORY_TOKEN = instruction_names.NEW_DIR_INSTRUCTION_NAME
FILE_TYPE_TOKENS = {
FileType.REGULAR: REGULAR_FILE_TOKEN,
FileType.DIR: DIRECTORY_TOKEN,
}
EXPLICIT_CREATE = instruction_arguments.ASSIGNMENT_OPERATOR
EXPLICIT_APPEND = instruction_arguments.APPEND_OPERATOR
MODIFICATION_VARIANT_TOKENS: Mapping[ModificationType, str] = {
ModificationType.CREATE: EXPLICIT_CREATE,
ModificationType.APPEND: EXPLICIT_APPEND,
}
EXPLICIT_CONTENTS_CONFIG: Mapping[str, ModificationType] = {
item[1]: item[0]
for item in MODIFICATION_VARIANT_TOKENS.items()
}
MODIFICATION_ARGUMENT__ASSIGN = a.Single(a.Multiplicity.MANDATORY,
a.Constant(EXPLICIT_CREATE))
MODIFICATION_ARGUMENT__APPEND = a.Single(a.Multiplicity.MANDATORY,
a.Constant(EXPLICIT_APPEND))
def test_constant(self):
self._check(sut.Constant('name'), sut.Constant)
def test_constant(self):
value = sut.Constant('name')
str(value)
def test_single(self):
value = sut.Single(sut.Multiplicity.OPTIONAL, sut.Constant('constant'))
str(value)
