def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
return [
a.Choice.of_single_argument_choices(
a.Multiplicity.OPTIONAL,
[
a.Option(names.STRIP_TRAILING_SPACE_OPTION_NAME),
a.Option(names.STRIP_TRAILING_NEW_LINES_OPTION_NAME),
],
)
]
class Description(grammar.PrimitiveDescriptionWithNameAsInitialSyntaxToken):
ARGUMENT_USAGE_LIST = (
a.Single(a.Multiplicity.OPTIONAL,
a.Option(matcher_options.FULL_MATCH_ARGUMENT_OPTION)),
syntax_elements.REGEX_SYNTAX_ELEMENT.single_mandatory,
)
@property
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
return self.ARGUMENT_USAGE_LIST
@property
def description_rest(self) -> Sequence[ParagraphItem]:
tp = TextParser({
'REGEX':
syntax_elements.REGEX_SYNTAX_ELEMENT.singular_name,
'full_regex_match':
option_syntax.option_syntax(
matcher_options.FULL_MATCH_ARGUMENT_OPTION),
'model':
matcher_model.TEXT_MODEL,
})
return tp.fnap(_DESCRIPTION)
@property
def see_also_targets(self) -> Sequence[SeeAlsoTarget]:
return syntax_elements.REGEX_SYNTAX_ELEMENT.cross_reference_target,
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 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) -> 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 _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)
)
class SyntaxDescription(
grammar.PrimitiveDescriptionWithNameAsInitialSyntaxToken):
OPTION_SYNTAX_ELEMENT = a.Choice.of_single_argument_choices(
a.Multiplicity.MANDATORY, [
a.Option(names.CHARACTER_CASE_TO_LOWER_OPTION_NAME),
a.Option(names.CHARACTER_CASE_TO_UPPER_OPTION_NAME),
])
@property
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
return (self.OPTION_SYNTAX_ELEMENT, )
@property
def description_rest(self) -> Sequence[ParagraphItem]:
return [self._options_table()]
@staticmethod
def _options_table() -> ParagraphItem:
return docs.simple_list_with_space_between_elements_and_content(
[
SyntaxDescription._item(
names.CHARACTER_CASE_TO_LOWER_OPTION_NAME,
TextParser({'case': _CASE__LOWER})),
SyntaxDescription._item(
names.CHARACTER_CASE_TO_UPPER_OPTION_NAME,
TextParser({'case': _CASE__UPPER})),
],
lists.ListType.VARIABLE_LIST,
)
@staticmethod
def _item(
option: a.OptionName,
tp: TextParser,
) -> lists.HeaderContentListItem:
return docs.list_item(
doc_format.syntax_text(option_syntax.option_syntax(option)),
tp.fnap(_DESCRIPTION))
def _stdin_sed() -> SyntaxElementDescription:
return cli_argument_syntax_element_description(
_STDIN_ARGUMENT,
(),
[
invokation_variant_from_args([
a.Single(
a.Multiplicity.MANDATORY,
a.Option(program.STDIN_OPTION_NAME,
argument=syntax_elements.
STRING_SOURCE_SYNTAX_ELEMENT.singular_name))
]),
],
_stdin_description_rest(),
)
def test_option(self):
self._check(sut.Option(sut.OptionName('n')), sut.Option)
def test_option(self):
value = sut.Option(sut.OptionName('s'), 'argument')
str(value)
from exactly_lib.util.cli_syntax.elements import argument as a
from . import matcher
WHOLE_PATH_MATCHER_NAME = 'path'
NAME_MATCHER_NAME = 'name'
STEM_MATCHER_NAME = 'stem'
SUFFIXES_MATCHER_NAME = 'suffixes'
SUFFIX_MATCHER_NAME = 'suffix'
TYPE_MATCHER_NAME = 'type'
PROGRAM_MATCHER_NAME = matcher.RUN_PROGRAM
PROGRAM_ARG_OPTION__LAST = a.Option(a.OptionName('path-arg-last'))
PROGRAM_ARG_OPTION__MARKER = a.Option(a.OptionName('path-arg-marker'),
'MARKER')
from exactly_lib.definitions.entity import types
from exactly_lib.util.cli_syntax import option_syntax
from exactly_lib.util.cli_syntax.elements import argument as a
from . import program
from ..test_case import reserved_words
IDENTITY_TRANSFORMER_NAME = 'identity'
SEQUENCE_OPERATOR_NAME = reserved_words.PIPE
RUN_PROGRAM = program.RUN_PROGRAM_PRIMITIVE
STRING_TRANSFORMER_ARGUMENT = a.Named(types.STRING_TRANSFORMER_TYPE_INFO.syntax_element_name)
STRING_TRANSFORMATION_ARGUMENT = a.Named('TRANSFORMATION')
WITH_TRANSFORMED_CONTENTS_OPTION_NAME = a.OptionName(long_name='transformed-by')
WITH_TRANSFORMED_CONTENTS_OPTION = option_syntax.option_syntax(WITH_TRANSFORMED_CONTENTS_OPTION_NAME)
TRANSFORMATION_OPTION = a.Option(WITH_TRANSFORMED_CONTENTS_OPTION_NAME,
argument=types.STRING_TRANSFORMER_TYPE_INFO.syntax_element_name)
WITH_IGNORED_EXIT_CODE_OPTION_NAME = program.WITH_IGNORED_EXIT_CODE_OPTION_NAME
def argument_usage_list(self) -> Sequence[a.ArgumentUsage]:
return [
a.Single(a.Multiplicity.OPTIONAL,
a.Option(names.RUN_WITH_IGNORED_EXIT_CODE_OPTION_NAME)),
syntax_elements.PROGRAM_SYNTAX_ELEMENT.single_mandatory,
]
from exactly_lib.common.help.see_also import SeeAlsoUrlInfo
from exactly_lib.common.help.syntax_contents_structure import cli_argument_syntax_element_description, \
invokation_variant_from_args
from exactly_lib.definitions.entity import syntax_elements
from exactly_lib.help.entities.syntax_elements.contents_structure import syntax_element_documentation
from exactly_lib.impls.types.regex import parse_regex
from exactly_lib.util.cli_syntax.elements import argument as a
from exactly_lib.util.textformat.textformat_parser import TextParser
_IGNORE_CASE_ARGUMENT = a.Option(parse_regex.IGNORE_CASE_OPTION_NAME)
_CL_ARGUMENTS = [
a.Single(a.Multiplicity.OPTIONAL, _IGNORE_CASE_ARGUMENT),
syntax_elements.RICH_STRING_SYNTAX_ELEMENT.single_mandatory,
]
SEE_ALSO_URL_INFO = SeeAlsoUrlInfo(
'Python regular expressions',
'https://docs.python.org/3/library/re.html#regular-expression-syntax')
_DESCRIPTION_OF_IGNORE_CASE_OPTION = """\
Makes the matching ignore case.
"""
DOCUMENTATION = syntax_element_documentation(
None, syntax_elements.REGEX_SYNTAX_ELEMENT, [], (), [
invokation_variant_from_args(_CL_ARGUMENTS),
], [
cli_argument_syntax_element_description(
_IGNORE_CASE_ARGUMENT,
TextParser().fnap(_DESCRIPTION_OF_IGNORE_CASE_OPTION))
def option_for(option_name: argument.OptionName,
argument_name: str = None) -> argument.Option:
return argument.Option(option_name, argument_name)
from exactly_lib.util.cli_syntax.elements import argument as a
from .entity import syntax_elements
from .path import REL_SYMBOL_OPTION_NAME
from .test_case import reserved_words
ASSIGNMENT_OPERATOR = reserved_words.ASSIGN
APPEND_OPERATOR = '+='
SYMBOL_SYNTAX_ELEMENT_NAME = 'SYMBOL'
REL_SYMBOL_OPTION = a.Option(REL_SYMBOL_OPTION_NAME,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.singular_name)
RELATIVITY_ARGUMENT = a.Named('RELATIVITY')
OPTIONAL_RELATIVITY_ARGUMENT_USAGE = a.Single(a.Multiplicity.OPTIONAL,
RELATIVITY_ARGUMENT)
FILE_ARGUMENT = a.Named('FILE')
DIR_WITHOUT_RELATIVITY_OPTIONS_ARGUMENT = a.Named('DIRECTORY')
DESTINATION_PATH_ARGUMENT = a.Named('DESTINATION')
SOURCE_PATH_ARGUMENT = a.Named('SOURCE')
FILE_NAME_STRING = a.Named('FILE-NAME')
FILE_NAME_STRING__SINGLE_MANDATORY = a.Single(a.Multiplicity.MANDATORY,
FILE_NAME_STRING)
from exactly_lib.definitions.entity import syntax_elements
from exactly_lib.definitions.primitives import program, string_transformer
from exactly_lib.util.cli_syntax.elements import argument as a
IDENTITY_TRANSFORMER_NAME = string_transformer.IDENTITY_TRANSFORMER_NAME
SEQUENCE_OPERATOR_NAME = string_transformer.SEQUENCE_OPERATOR_NAME
RUN_PROGRAM_TRANSFORMER_NAME = string_transformer.RUN_PROGRAM
RUN_WITH_IGNORED_EXIT_CODE_OPTION_NAME = program.WITH_IGNORED_EXIT_CODE_OPTION_NAME
REPLACE_TRANSFORMER_NAME = 'replace'
FILTER_TRANSFORMER_NAME = 'filter'
GREP_TRANSFORMER_NAME = 'grep'
RANGE_EXPR_SED_NAME = 'LINE-NUMBER-RANGE'
LINE_NUMBERS_FILTER_OPTION = a.Option(a.OptionName('line-nums'))
LINE_NUMBERS_FILTER__LIMIT_SEPARATOR = ':'
CHARACTER_CASE = 'char-case'
CHARACTER_CASE_TO_LOWER_OPTION_NAME = a.OptionName(long_name='to-lower')
CHARACTER_CASE_TO_UPPER_OPTION_NAME = a.OptionName(long_name='to-upper')
STRIP_SPACE = 'strip'
STRIP_TRAILING_SPACE_OPTION_NAME = a.OptionName(long_name='trailing-space')
STRIP_TRAILING_NEW_LINES_OPTION_NAME = a.OptionName(
long_name='trailing-new-lines')
TCDS_PATH_REPLACEMENT = 'replace-test-case-dirs'
LINES_SELECTION_OPTION_NAME = a.OptionName(long_name='at')
