def test_choice(self): self._check( sut.Choice.of_single_argument_choices( sut.Multiplicity.MANDATORY, [sut.Named('arg1'), sut.Named('arg2')]), sut.Choice, )
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 test_choice__single_argument_choices(self): # ARRANGE # renderer = sut.ArgumentUsageOnCommandLineRenderer() argument_usage = arg.Choice.of_single_argument_choices( arg.Multiplicity.OPTIONAL, [arg.Named('name1'), arg.Named('name2')], ) # ACT # actual = renderer.visit(argument_usage) # ASSERT # self.assertEqual('[name1|name2]', actual)
def invokation_variants(self) -> Sequence[InvokationVariant]: from exactly_lib.definitions.entity.actors import SOURCE_INTERPRETER_ACTOR source_interpreter_arg = a.Single(a.Multiplicity.MANDATORY, a.Named(SOURCE_INTERPRETER_NAME)) file_interpreter_arg = a.Single(a.Multiplicity.MANDATORY, a.Named(FILE_INTERPRETER_NAME)) return ( self._command_line_invokation_variant(), self._interpreter_actor_invokation_variant(FILE_INTERPRETER_ACTOR, file_interpreter_arg), self._interpreter_actor_invokation_variant( SOURCE_INTERPRETER_ACTOR, source_interpreter_arg), self._null_invokation_variant(), )
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]: return [ a.Choice.of_single_argument_choices( a.Multiplicity.MANDATORY, [a.Named(value) for value in logic.BOOLEANS.values()] ) ]
def path_element_3( rel_options_conf: RelOptionArgumentConfiguration, custom_paragraphs: Sequence[ParagraphItem] = () ) -> SyntaxElementDescriptionTree: return SyntaxElementDescriptionTreeFromSed( a.Named(rel_options_conf.argument_syntax_name), path_element_2(rel_options_conf, custom_paragraphs))
def _choice_w_multiple_args_from_strings( multiplicity: arg.Multiplicity, choices: List[List[str]], ) -> arg.Choice: return arg.Choice.of_multiple_argument_choices( multiplicity, [[arg.Named(choice_arg) for choice_arg in choice] for choice in choices])
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)) ]
def test_named_argument_SHOULD_produce_name(self): # ARRANGE # renderer = sut.ArgumentOnCommandLineRenderer() argument_usage = arg.Named('the_name') # ACT # actual = renderer.visit(argument_usage) # ASSERT # self.assertEqual('the_name', actual)
def __init__(self): super().__init__(directives.INCLUDING_DIRECTIVE_INFO) self.file_argument = a.Named( file_inclusion_directive_parser.FILE_ARGUMENT_NAME) self._tp = TextParser({ 'including_directive': self.info.singular_name, 'FILE': self.file_argument.name, })
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 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 test_single(self): # ARRANGE # renderer = sut.ArgumentUsageOnCommandLineRenderer() argument_usage = arg.Single(arg.Multiplicity.OPTIONAL, arg.Named('name')) # ACT # actual = renderer.visit(argument_usage) # ASSERT # self.assertEqual('[name]', actual)
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 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 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 test_choice__single_argument_choices(self): # ARRANGE # args_cases = [ ['name1', 'name2'], ['name1', 'name2', 'name3'], ] renderer = sut.ArgumentUsageOnCommandLineRenderer() for args_case in args_cases: with self.subTest(repr(args_case)): argument_usage = arg.Choice.of_single_argument_choices( arg.Multiplicity.ONE_OR_MORE, [arg.Named(arg_name) for arg_name in args_case], ) # ACT # actual = renderer.visit(argument_usage) # ASSERT # self.assertEqual('({})...'.format('|'.join(args_case)), actual)
class SyntaxDescription(grammar.PrimitiveDescriptionWithNameAsInitialSyntaxToken): LINES_SELECTOR = a.Named('LINES-SELECTION') @property def argument_usage_list(self) -> Sequence[a.ArgumentUsage]: return [ a.Single(a.Multiplicity.OPTIONAL, self.LINES_SELECTOR), a.Single(a.Multiplicity.OPTIONAL, names.PRESERVE_NEW_LINES_OPTION), a.Single(a.Multiplicity.MANDATORY, _REGEX_ARGUMENT), a.Single(a.Multiplicity.MANDATORY, _REPLACEMENT_ARGUMENT), ] @property def description_rest(self) -> Sequence[ParagraphItem]: return _TEXT_PARSER.fnap(_DESCRIPTION) @property def syntax_elements(self) -> Sequence[SyntaxElementDescription]: return [ self._lines_selection_syntax_elements() ] def _lines_selection_syntax_elements(self) -> SyntaxElementDescription: description = _TEXT_PARSER.fnap(_DESCRIPTION__LINES_SELECTION) description += texts.type_expression_has_syntax_of_primitive([ names.LINES_SELECTION_OPTION.argument, ]) return SyntaxElementDescription( self.LINES_SELECTOR.name, (), [ invokation_variant_from_args( [a.Single(a.Multiplicity.MANDATORY, names.LINES_SELECTION_OPTION)], ) ], description, ) @property def see_also_targets(self) -> Sequence[SeeAlsoTarget]: return [syntax_elements.REGEX_SYNTAX_ELEMENT.cross_reference_target]
[ invokation_variant_from_args( [a.Single(a.Multiplicity.MANDATORY, names.LINES_SELECTION_OPTION)], ) ], description, ) @property def see_also_targets(self) -> Sequence[SeeAlsoTarget]: return [syntax_elements.REGEX_SYNTAX_ELEMENT.cross_reference_target] _REGEX_ARGUMENT = syntax_elements.REGEX_SYNTAX_ELEMENT.argument _REPLACEMENT_ARGUMENT = a.Named(types.STRING_TYPE_INFO.syntax_element_name) _MISSING_REPLACEMENT_ARGUMENT_ERR_MSG = 'Missing ' + _REPLACEMENT_ARGUMENT.name _PARSE_REPLACEMENT_CONFIGURATION = parse_string.Configuration('REPLACEMENT') _TEXT_PARSER = TextParser({ 'preserve_new_lines_option': formatting.argument_option(names.PRESERVE_NEW_LINES_OPTION_NAME), '_REG_EX_': _REGEX_ARGUMENT.name, '_STRING_': _REPLACEMENT_ARGUMENT.name, 'plain_string': misc_texts.PLAIN_STRING, 'LINES_SELECTOR_MATCHER': names.LINES_SELECTION_OPTION.argument, 'line_matcher_model': matcher_model.LINE_MATCHER_MODEL, 'Note': headers.NOTE_LINE_HEADER, 'NL': formatting.string_constant('\\n'), 'LINES_ARE_SEPARATED_BY_NEW_LINE': misc_texts.LINES_ARE_SEPARATED_BY_NEW_LINE, })
syntax_elements: Sequence[SyntaxElementDescription] = (), see_also_targets: Sequence[SeeAlsoTarget] = (), operand_evaluation__lazy__left_to_right: bool = False, ): self._description_rest = description_rest self._see_also_targets = list(see_also_targets) self._syntax_elements = syntax_elements self._operand_evaluation__lazy__left_to_right = operand_evaluation__lazy__left_to_right @property def description_rest(self) -> Sequence[ParagraphItem]: return self._description_rest @property def syntax_elements(self) -> Sequence[SyntaxElementDescription]: return self._syntax_elements @property def see_also_targets(self) -> Sequence[SeeAlsoTarget]: return self._see_also_targets @property def operand_evaluation__lazy__left_to_right(self) -> bool: return self._operand_evaluation__lazy__left_to_right CONCEPT = grammar.Concept( NameWithGenderWithFormatting( NameWithGender('a', 'concept singular', 'concept plural')), 'type-system-name', a.Named('SYNTAX-ELEMENT-NAME'))
def argument(self) -> a.Named: return a.Named(self.singular_name)
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: TypeInfo(types.LIST_TYPE_INFO, [syntax_elements.LIST_SYNTAX_ELEMENT.single_mandatory]), }) def _logic_type_info(type_info: TypeNameAndCrossReferenceId) -> TypeInfo: return TypeInfo(type_info, _standard_type_value_args(type_info)) ANY_TYPE_INFO_DICT: Mapping[ValueType, TypeInfo] = { ValueType.STRING: TYPE_W_STR_RENDERING_INFO_DICT[WithStrRenderingType.STRING], ValueType.PATH:
def _test_suite_option_argument(self) -> cli_syntax.DescribedArgument: return cli_syntax.DescribedArgument( SUITE_OPTION_ARGUMENT, _TP.fnap(_CORRESPONDS_TO_TEST_SUITE_ARGUMENT)) def see_also(self) -> List[SeeAlsoTarget]: return [ PredefinedHelpContentsPartReference( HelpPredefinedContentsPart.TEST_CASE_CLI), PredefinedHelpContentsPartReference( HelpPredefinedContentsPart.TEST_SUITE_CLI), ] CASE_OPTION_ARGUMENT = arg.Named('TEST-CASE-OPTION') SUITE_OPTION_ARGUMENT = arg.Named('TEST-SUITE-OPTION') SYMBOL_OPTION_ARGUMENT = arg.Named('SYMBOL-OPTION') def synopsis_general() -> cli_syntax.Synopsis: command_line = _command_line__case( [arg.Single(arg.Multiplicity.ZERO_OR_MORE, SYMBOL_OPTION_ARGUMENT)]) return cli_syntax.Synopsis( command_line, _TP.text(_SINGLE_LINE_DESCRIPTION_FOR_CLI_SYNTAX)) def synopsis_all() -> cli_syntax.Synopsis: return cli_syntax.Synopsis( _command_line__case([]), paragraphs=_TP.fnap(_DESCRIPTION_PARAGRAPHS_ALL),
def test_single(self): self._check( sut.Single(sut.Multiplicity.MANDATORY, sut.Named('value-element')), sut.Single)
def test_named(self): value = sut.Named('name') str(value)
from exactly_lib.symbol.value_type import ValueType from exactly_lib.type_val_deps.types.file_matcher import FileMatcherSdv from exactly_lib.type_val_prims.matcher.file_matcher import FileMatcher from exactly_lib.util.cli_syntax.elements import argument as a from exactly_lib.util.name_and_value import NameAndValue from exactly_lib.util.textformat.structure import structures as docs from exactly_lib.util.textformat.structure.core import ParagraphItem from exactly_lib.util.textformat.structure.document import SectionContents from exactly_lib.util.textformat.structure.table import TableCell from exactly_lib.util.textformat.textformat_parser import TextParser from .impl.names import parsers as names_parsers, doc as names_doc from ... import file_properties NAME_MATCHER_ARGUMENT = syntax_elements.GLOB_PATTERN_SYNTAX_ELEMENT.argument TYPE_MATCHER_ARGUMENT = a.Named('TYPE') def parsers(must_be_on_current_line: bool = False) -> GrammarParsers[FileMatcherSdv]: return _PARSERS_FOR_MUST_BE_ON_CURRENT_LINE[must_be_on_current_line] def _parse_type_matcher(parser: TokenParser) -> FileMatcherSdv: file_type = parser.consume_mandatory_constant_string_that_must_be_unquoted_and_equal( file_properties.SYNTAX_TOKEN_2_FILE_TYPE, file_properties.SYNTAX_TOKEN_2_FILE_TYPE.get, TYPE_MATCHER_ARGUMENT.name) return sdv_components.matcher_sdv_from_constant_primitive(FileMatcherType(file_type)) def _parse_regular_file_contents(token_parser: TokenParser) -> FileMatcherSdv:
def test_named(self): self._check(sut.Named('value-element'), sut.Named)
from typing import List from exactly_lib.common.help.syntax_contents_structure import InvokationVariant from exactly_lib.definitions import instruction_arguments from exactly_lib.definitions.argument_rendering import cl_syntax from exactly_lib.section_document.element_parsers.instruction_parser_exceptions import \ SingleInstructionInvalidArgumentException from exactly_lib.section_document.element_parsers.misc_utils import split_arguments_list_string from exactly_lib.util.cli_syntax.elements import argument as a from exactly_lib.util.messages import expected_found MANDATORY_EQ_ARG = a.Single(a.Multiplicity.MANDATORY, a.Named(instruction_arguments.ASSIGNMENT_OPERATOR)) def single_eq_invokation_variants(mandatory_arg: a.Argument) -> list: args = [ MANDATORY_EQ_ARG, a.Single(a.Multiplicity.MANDATORY, mandatory_arg), ] return [ InvokationVariant(cl_syntax.cl_syntax_for_args(args)), ] def extract_single_eq_argument_string(syntax_element: str, rest_of_line: str) -> str: arguments = rest_of_line.strip().split(maxsplit=1) if not arguments: raise SingleInstructionInvalidArgumentException( _missing(instruction_arguments.ASSIGNMENT_OPERATOR))