def _matcher_sed(self) -> SyntaxElementDescription:
mandatory_empty_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(EMPTY_ARGUMENT))
quantifier_arg = a.Choice(a.Multiplicity.MANDATORY,
[
a.Constant(
instruction_arguments.EXISTS_QUANTIFIER_ARGUMENT),
a.Constant(
instruction_arguments.ALL_QUANTIFIER_ARGUMENT),
])
equals_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(
matcher_options.EQUALS_ARGUMENT))
line_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(matcher_options.LINE_ARGUMENT))
quantifier_separator_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(instruction_arguments.QUANTIFICATION_SEPARATOR_ARGUMENT))
line_matcher_arg = a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.LINE_MATCHER)
num_lines_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(matcher_options.NUM_LINES_ARGUMENT))
symbol_argument = a.Single(a.Multiplicity.MANDATORY,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument)
return SyntaxElementDescription(
self.matcher_element_name,
[],
[
invokation_variant_from_args([mandatory_empty_arg],
self._parser.fnap(_DESCRIPTION_OF_EMPTY)),
invokation_variant_from_args([equals_arg,
self.string_or_here_doc_or_file_arg.argument_usage(
a.Multiplicity.MANDATORY),
],
self._parser.fnap(_DESCRIPTION_OF_EQUALS_STRING)),
self._matches_regex_invokation_variant(),
invokation_variant_from_args([num_lines_arg,
syntax_elements.INTEGER_COMPARISON_SYNTAX_ELEMENT.single_mandatory,
],
self._parser.fnap(_DESCRIPTION_OF_NUM_LINES)),
invokation_variant_from_args([quantifier_arg,
line_arg,
quantifier_separator_arg,
line_matcher_arg,
],
self._parser.fnap(_DESCRIPTION_OF_LINE_MATCHES)),
invokation_variant_from_args([symbol_argument],
self._parser.fnap(_SYMBOL_REF_DESCRIPTION)),
])
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 invokation_variants__stdout_err(self, program_option: a.OptionName) -> List[InvokationVariant]:
return [
invokation_variant_from_args(
file_contents_checker_arguments__non_program(),
self._tp.fnap(_MAIN_INVOKATION__STDOUT_ERR_ACTION_TO_CHECK__SYNTAX_DESCRIPTION)
),
invokation_variant_from_args(
file_contents_checker_arguments__program(program_option),
self._tp.fnap(_MAIN_INVOKATION__STDOUT_ERR_PROGRAM__SYNTAX_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 invokation_variants(self) -> List[InvokationVariant]:
arguments = path_syntax.mandatory_path_with_optional_relativity(
_DST_PATH_ARGUMENT,
REL_OPT_ARG_CONF.path_suffix_is_required)
contents_arg = a.Single(a.Multiplicity.MANDATORY,
a.Named(CONTENTS_ARGUMENT))
assignment_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(CONTENTS_ASSIGNMENT_TOKEN))
return [
invokation_variant_from_args(arguments,
docs.paras('Creates an empty file.')),
invokation_variant_from_args(arguments + [assignment_arg, contents_arg],
self._tp.paras('Creates a file with contents given by {CONTENTS}.')),
]
def invokation_variants(self) -> List[InvokationVariant]:
shell_cmd_arg = a.Single(a.Multiplicity.MANDATORY,
syntax_elements.SHELL_COMMAND_LINE_SYNTAX_ELEMENT.argument)
return [
invokation_variant_from_args([MANDATORY_EQ_ARG,
shell_cmd_arg]),
]
def _command_line_invokation_variants(self) -> List[InvokationVariant]:
command_line_actor_arg = a.Single(a.Multiplicity.MANDATORY,
a.Option(COMMAND_LINE_ACTOR_OPTION_NAME))
return [
invokation_variant_from_args([MANDATORY_EQ_ARG, command_line_actor_arg],
self._description_of_command_line()),
]
def _specific_invocation_invokation_variants(self) -> List[syntax_contents_structure.InvokationVariant]:
return [
syntax_contents_structure.invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, a.Option(OUTPUT_FROM_PROGRAM_OPTION_NAME)),
a.Single(a.Multiplicity.MANDATORY, syntax_elements.PROGRAM_SYNTAX_ELEMENT.argument),
]),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
syntax_elements.STRING_SYNTAX_ELEMENT.single_mandatory,
syntax_elements.PROGRAM_ARGUMENT_SYNTAX_ELEMENT.zero_or_more,
], []),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
self.command_arg)],
[]),
]
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 invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, self._pgm_and_args.element),
a.Single(a.Multiplicity.OPTIONAL, instruction_arguments.STRING_TRANSFORMATION_ARGUMENT),
]),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
negation_of_predicate.optional_negation_argument_usage(),
syntax_elements.INTEGER_COMPARISON_SYNTAX_ELEMENT.single_mandatory,
]),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.OPTIONAL,
_DIR_ARGUMENT),
]),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
_DIR_ARGUMENT),
]),
]
def invokation_variants(self) -> List[InvokationVariant]:
arguments = path_syntax.mandatory_path_with_optional_relativity(
_PATH_ARGUMENT,
RELATIVITY_VARIANTS.path_suffix_is_required)
return [
invokation_variant_from_args(arguments,
[]),
]
def _exe_file() -> InvokationVariant:
return invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.PATH_ARGUMENT)
],
_TEXT_PARSER.fnap(_EXE_FILE_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 invokation_variants__file(self, actual_file: a.Named) -> List[InvokationVariant]:
actual_file_arg = a.Single(a.Multiplicity.MANDATORY,
actual_file)
return [
invokation_variant_from_args(
[actual_file_arg] + file_contents_checker_arguments__non_program(),
self._tp.fnap(_MAIN_INVOKATION__FILE__SYNTAX_DESCRIPTION)),
]
def _python() -> InvokationVariant:
return invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
a.Option(pgm_syntax_elements.PYTHON_EXECUTABLE_OPTION_NAME))
],
_TEXT_PARSER.fnap(_PYTHON_EXECUTABLE_DESCRIPTION)
)
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 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 _interpreter_actor_invokation_variant(
self, actor_w_interpreter: SingularNameAndCrossReferenceId,
cli_option: a.Single) -> InvokationVariant:
return invokation_variant_from_args([
MANDATORY_EQ_ARG,
cli_option,
syntax_elements.ACT_INTERPRETER_SYNTAX_ELEMENT.single_mandatory,
], self._description_of_actor_with_interpreter(actor_w_interpreter))
def _exe_file() -> InvokationVariant:
return invokation_variant_from_args(
[syntax_elements.PATH_SYNTAX_ELEMENT.single_mandatory],
rel_path_doc.path_element_relativity_paragraphs(
path_relativities.REL_OPTIONS_CONFIGURATION,
_TEXT_PARSER.paras(the_path_of('{executable_file:a}.')),
_TEXT_PARSER.fnap(_DIFFERENT_RELATIVITIES_FOR_PROGRAM_ACTOR),
))
def invokation_variants(self) -> List[InvokationVariant]:
executable_arg = a.Single(a.Multiplicity.MANDATORY, self.file)
return [
invokation_variant_from_args([
executable_arg,
syntax_elements.PROGRAM_ARGUMENT_SYNTAX_ELEMENT.zero_or_more,
]),
]
def _pgm_for_arg_list_variant(self) -> InvokationVariant:
return invokation_variant_from_args(
[
a.single_mandatory(self._pgm_for_arg_list.element),
syntax_elements.PROGRAM_ARGUMENT_SYNTAX_ELEMENT.zero_or_more,
],
self._pgm_for_arg_list_variant_description(),
)
def python_interpreter(arguments: List[a.ArgumentUsage]) -> InvokationVariant:
return invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
a.Option(pgm_syntax_elements.PYTHON_EXECUTABLE_OPTION_NAME))
] +
arguments,
_TEXT_PARSER.fnap(_PYTHON_INTERPRETER_DESCRIPTION)
)
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 invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
self._src_rel_opt_arg_conf.argument),
a.Single(a.Multiplicity.OPTIONAL,
REL_OPTION_ARG_CONF_FOR_DESTINATION.argument)]
),
]
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.SOURCE_PATH_ARGUMENT),
a.Single(a.Multiplicity.OPTIONAL,
instruction_arguments.DESTINATION_PATH_ARGUMENT)]
),
]
def _name_sed(self) -> SyntaxElementDescription:
return SyntaxElementDescription(
defs.VAR_NAME_ELEMENT,
(),
[
invokation_variant_from_args(
[syntax_elements.STRING_SYNTAX_ELEMENT.single_mandatory])
],
)
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.single_mandatory(self._pgm_and_args.element),
a.Single(a.Multiplicity.OPTIONAL, _STDIN_ARGUMENT),
a.Single(a.Multiplicity.OPTIONAL,
a.Named(_OUTPUT_TRANSFORMATION)),
]),
]
def _transformation_sed(self) -> SyntaxElementDescription:
return cli_argument_syntax_element_description(
instruction_arguments.STRING_TRANSFORMATION_ARGUMENT,
_TEXT_PARSER.fnap(_TRANSFORMATION_DESCRIPTION),
[
invokation_variant_from_args([a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.TRANSFORMATION_OPTION)]),
]
)
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.OPTIONAL,
a.Option(IGNORE_EXIT_CODE_OPTION_NAME)),
a.Single(a.Multiplicity.MANDATORY,
syntax_elements.PROGRAM_SYNTAX_ELEMENT.argument),
]),
]
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 _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,
instruction_arguments.TEXT_UNTIL_END_OF_LINE_ARGUMENT)
],
_TEXT_PARSER.fnap(_ARGUMENT__TEXT_UNTIL_END_OF_LINE_DESCRIPTION)
)
def _existing_file() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
a.Option(pgm_syntax_elements.EXISTING_FILE_OPTION_NAME)),
a.Single(a.Multiplicity.MANDATORY,
PATH_OF_EXISTING_FILE_OPT_CONFIG.argument)
],
_TEXT_PARSER.fnap(_ARGUMENT__EXISTING_FILE_DESCRIPTION)
)
def invokation_variants(self) -> List[InvokationVariant]:
optional_transformation_option = a.Single(
a.Multiplicity.OPTIONAL,
string_transformer.STRING_TRANSFORMATION_ARGUMENT)
program_token = syntax_elements.PROGRAM_SYNTAX_ELEMENT.single_mandatory
output_channel_token = a.Choice.of_single_argument_choices(
a.Multiplicity.MANDATORY, [
a.Option(option_name)
for option_name in defs.PROGRAM_OUTPUT_OPTIONS.values()
])
ignore_exit_code_token = a.Single(a.Multiplicity.OPTIONAL,
a.Option(defs.IGNORE_EXIT_CODE))
file_option = a.Single(a.Multiplicity.MANDATORY,
a.Option(defs.FILE_OPTION))
src_file_arg = a.Single(a.Multiplicity.MANDATORY,
defs.SOURCE_FILE_ARGUMENT_NAME)
return [
invokation_variant_from_args(
[
syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.
single_mandatory, optional_transformation_option
],
self._tp.fnap(_REFERENCE_DESCRIPTION),
),
invokation_variant_from_args([
syntax_elements.RICH_STRING_SYNTAX_ELEMENT.single_mandatory,
optional_transformation_option
]),
invokation_variant_from_args([
file_option,
src_file_arg,
optional_transformation_option,
], self._tp.fnap(_FILE_DESCRIPTION)),
invokation_variant_from_args(
[output_channel_token, ignore_exit_code_token, program_token],
self._tp.fnap(_PROGRAM_DESCRIPTION) + texts.
run_description__with_ignored_exit_code_option__w_str_trans()),
]
def _phase_spec_sed(self) -> SyntaxElementDescription:
phase_spec__act = a.Option(defs.PHASE_SPEC__OPTION_NAME,
defs.PHASE_SPEC__ACT)
phase_spec__non_act = a.Option(defs.PHASE_SPEC__OPTION_NAME,
defs.PHASE_SPEC__NON_ACT)
return SyntaxElementDescription(
defs.PHASE_SPEC_ELEMENT,
invokation_variants=[
invokation_variant_from_args(
[a.Single(a.Multiplicity.MANDATORY, phase_spec__act)],
self._tp.fnap(_DESCRIPTION__PHASE_SPEC__ACT),
),
invokation_variant_from_args(
[a.Single(a.Multiplicity.MANDATORY, phase_spec__non_act)],
self._tp.fnap(_DESCRIPTION__PHASE_SPEC__NON_ACT),
),
],
before_invokation_variants=(),
)
def invokation_variants(self) -> List[InvokationVariant]:
actual_file_arg = a.Single(a.Multiplicity.MANDATORY,
self.actual_file_arg)
return [
invokation_variant_from_args([
actual_file_arg,
common_arguments.RESERVED_WORD__COLON,
syntax_elements.STRING_MATCHER_SYNTAX_ELEMENT.single_mandatory,
], self._tp.fnap(_MAIN_INVOKATION__FILE__SYNTAX_DESCRIPTION)),
]
def _file_name_sed() -> SyntaxElementDescription:
return SyntaxElementDescription(
syntax.FILE_NAME.name,
(),
[
invokation_variant_from_args(
[syntax_elements.STRING_SYNTAX_ELEMENT.single_mandatory])
],
_TP.fnap(_FILE_NAME_DESCRIPTION_REST),
)
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 _existing_path(option: a.OptionName,
description_rest: str) -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY,
a.Option(option)),
a.Single(a.Multiplicity.MANDATORY,
PATH_OF_EXISTING_FILE_OPT_CONFIG.argument)
],
_TEXT_PARSER.fnap(description_rest)
)
def syntax_elements(self) -> Sequence[SyntaxElementDescription]:
from exactly_lib.definitions.primitives import file_matcher
return [
SyntaxElementDescription(
self._ARG_POS.name,
self._tp().fnap(_PATH_ARG_POS__DESCRIPTION), [
invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
file_matcher.PROGRAM_ARG_OPTION__LAST)
],
self._tp().fnap(_PATH_ARG_POS__LAST__DESCRIPTION)),
invokation_variant_from_args(
[
a.Single(a.Multiplicity.MANDATORY,
file_matcher.PROGRAM_ARG_OPTION__MARKER)
],
self._tp().fnap(_PATH_ARG_POS__MARKER__DESCRIPTION)),
])
]
def _matches_regex_invokation_variant(self) -> InvokationVariant:
matches_regex_arg = a.Single(a.Multiplicity.MANDATORY,
a.Constant(
matcher_options.MATCHES_ARGUMENT))
return invokation_variant_from_args([matches_regex_arg,
a.Single(a.Multiplicity.OPTIONAL,
a.Option(matcher_options.FULL_MATCH_ARGUMENT_OPTION)),
syntax_elements.REGEX_SYNTAX_ELEMENT.single_mandatory,
],
self._parser.fnap(_DESCRIPTION_OF_MATCHES_REGEX))
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 _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 _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 _system_program() -> 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
),
],
_TEXT_PARSER.fnap(_SYSTEM_PROGRAM_DESCRIPTION)
)
def _interpreter_actor_invokation_variants(self,
actor: SingularNameAndCrossReferenceId,
cli_option: a.Single) -> List[InvokationVariant]:
shell_interpreter_argument = a.Single(a.Multiplicity.MANDATORY,
a.Constant(SHELL_COMMAND_INTERPRETER_ACTOR_KEYWORD))
command_argument = a.Single(a.Multiplicity.MANDATORY, self.command_line_syntax.command)
executable_arg = a.Single(a.Multiplicity.MANDATORY, self.command_line_syntax.executable)
optional_arguments_arg = a.Single(a.Multiplicity.ZERO_OR_MORE, self.command_line_syntax.argument)
return [
invokation_variant_from_args([MANDATORY_EQ_ARG,
cli_option,
executable_arg,
optional_arguments_arg],
self._description_of_executable_program_interpreter(actor)),
invokation_variant_from_args([MANDATORY_EQ_ARG,
cli_option,
shell_interpreter_argument,
command_argument],
self._description_of_shell_command_interpreter(actor)),
]
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 invokation_variants(self) -> List[InvokationVariant]:
matcher_arg = a.Single(a.Multiplicity.MANDATORY,
a.Named(self.matcher_element_name))
optional_transformation_option = a.Single(a.Multiplicity.OPTIONAL,
instruction_arguments.STRING_TRANSFORMATION_ARGUMENT)
return [
invokation_variant_from_args([
optional_transformation_option,
negation_of_predicate.optional_negation_argument_usage(),
matcher_arg,
])
]
def invokation_variants(self) -> List[InvokationVariant]:
negation_arguments = [negation_of_predicate.optional_negation_argument_usage()]
path_arguments = path_syntax.mandatory_path_with_optional_relativity(
_PATH_ARGUMENT,
_REL_OPTION_CONFIG.path_suffix_is_required)
file_matcher_arguments = [a.Single(a.Multiplicity.OPTIONAL, self.PROPERTIES)]
return [
invokation_variant_from_args(negation_arguments +
path_arguments +
file_matcher_arguments,
[]),
]
def _file_contents_sed(self) -> SyntaxElementDescription:
optional_transformation_option = a.Single(a.Multiplicity.OPTIONAL,
instruction_arguments.STRING_TRANSFORMATION_ARGUMENT)
here_doc_arg = a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.HERE_DOCUMENT)
string_arg = a.Single(a.Multiplicity.MANDATORY,
instruction_arguments.STRING)
program_token = a.Single(a.Multiplicity.MANDATORY,
syntax_elements.PROGRAM_SYNTAX_ELEMENT.argument)
output_channel_token = a.Choice(a.Multiplicity.MANDATORY,
[a.Option(option_name) for option_name in PROGRAM_OUTPUT_OPTIONS.values()])
file_option = a.Single(a.Multiplicity.MANDATORY,
a.Option(FILE_OPTION))
src_file_arg = a.Single(a.Multiplicity.MANDATORY,
_SRC_PATH_ARGUMENT)
invokation_variants = [
invokation_variant_from_args([string_arg]),
invokation_variant_from_args([here_doc_arg]),
invokation_variant_from_args([file_option,
src_file_arg,
optional_transformation_option,
],
self._tp.fnap(_FILE_DESCRIPTION)),
invokation_variant_from_args([output_channel_token,
program_token],
self._tp.fnap(_PROGRAM_DESCRIPTION)),
]
return SyntaxElementDescription(self._contents_argument_sed,
[],
invokation_variants)
def _string() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, syntax_elements.STRING_SYNTAX_ELEMENT.argument),
],
_TEXT_PARSER.fnap(_ARGUMENT__STRING_DESCRIPTION)
)
def _pgm_for_arg_list_variant(self) -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, self._pgm_for_arg_list.element),
a.Single(a.Multiplicity.ZERO_OR_MORE, self._arg.element),
],
_TEXT_PARSER.fnap(_PGM_WITH_ARG_LIST_INVOKATION_VARIANT_DESCRIPTION))
def invokation_variants(self) -> List[InvokationVariant]:
return [
invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, syntax_elements.PROGRAM_SYNTAX_ELEMENT.argument),
]),
]
def _properties_invokation_variant() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(a.Multiplicity.MANDATORY, a.Constant(PROPERTIES_SEPARATOR)),
syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.single_mandatory,
])
