def _simple_expressions(
) -> Sequence[NameAndValue[grammar.Primitive[FilesMatcherSdv]]]:
ret_val = [
NameAndValue(
config.EMPTINESS_CHECK_ARGUMENT,
grammar.Primitive(_parse_empty_check, documentation.EmptyDoc())),
NameAndValue(
config.MATCHES_ARGUMENT,
grammar.Primitive(_parse_matches, documentation.MatchesDoc())),
]
quantification_setup = parse_quantified_matcher.GrammarSetup(
quant_over_files.ELEMENT_SETUP,
parse_file_matcher.parsers().simple,
)
ret_val += quantification_setup.quantification_grammar_expressions()
ret_val += [
NameAndValue(
config.NUM_FILES_CHECK_ARGUMENT,
grammar.Primitive(num_files.parser().parse,
documentation.NumFilesDoc())),
NameAndValue(
option_syntax.option_syntax(config.SELECTION_OPTION.name),
grammar.Primitive(_parse_selection, documentation.SelectionDoc())),
NameAndValue(option_syntax.option_syntax(config.PRUNE_OPTION.name),
grammar.Primitive(_parse_prune,
documentation.PruneDoc())),
]
return ret_val
class TestParseInvalidSyntax(instruction_check.TestCaseBase):
test_cases_with_no_negation_operator = [
'',
'{type_option} file-name'.format(
type_option=option_syntax(OptionName(file_properties.TYPE_INFO[FileType.REGULAR].type_argument))),
'{type_option}'.format(
type_option=option_syntax(OptionName(file_properties.TYPE_INFO[FileType.DIRECTORY].type_argument))),
'{invalid_option} file-name'.format(
invalid_option=long_option_syntax('invalidOption')),
'file-name unexpectedArgument',
]
def test_raise_exception_WHEN_syntax_is_invalid(self):
self._assert_each_case_raises_SingleInstructionInvalidArgumentException(
self.test_cases_with_no_negation_operator)
def test_raise_exception_WHEN_syntax_is_invalid_WITH_not_operator(self):
test_cases_with_negation_operator = [
with_negation_argument(case_with_no_negation_operator)
for case_with_no_negation_operator in self.test_cases_with_no_negation_operator
]
self._assert_each_case_raises_SingleInstructionInvalidArgumentException(
test_cases_with_negation_operator)
def _assert_each_case_raises_SingleInstructionInvalidArgumentException(self, test_cases: list):
parser = sut.Parser()
for instruction_argument in test_cases:
with self.subTest(instruction_argument=instruction_argument):
for source in equivalent_source_variants(self, instruction_argument):
with self.assertRaises(SingleInstructionInvalidArgumentException):
parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
def test_successful_single_last_line(self):
test_cases = [
'{file_option} file'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
),
'{file_option} {relativity_option} "file name with space"'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
relativity_option=option_syntax(REL_HOME_CASE_OPTION_NAME),
),
]
parser = sut.Parser()
for instruction_argument in test_cases:
for source in equivalent_source_variants__with_source_check(self, assignment_str_of(instruction_argument)):
parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
def test_file__rel_home(self):
accepted_relativity_options = [
rel_opt_conf.conf_rel_any(RelOptionType.REL_HOME_CASE),
rel_opt_conf.default_conf_rel_any(RelOptionType.REL_HOME_CASE),
rel_opt_conf.symbol_conf_rel_any(
RelOptionType.REL_HOME_CASE,
'SYMBOL',
sut.RELATIVITY_OPTIONS_CONFIGURATION.options.accepted_relativity_variants),
]
for rel_opt in accepted_relativity_options:
with self.subTest(option_string=rel_opt.option_argument):
self._run(assignment_of('{file_option} {relativity_option} file.txt'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
relativity_option=rel_opt.option_argument),
['following line']),
Arrangement(
hds_contents=case_home_dir_contents(
DirContents([empty_file('file.txt')])),
symbols=rel_opt.symbols.in_arrangement(),
),
Expectation(
settings_builder=AssertStdinFileIsSetToFile(
file_refs.of_rel_option(RelOptionType.REL_HOME_CASE,
file_refs.constant_path_part('file.txt'))),
symbol_usages=rel_opt.symbols.usages_expectation(),
source=is_at_beginning_of_line(2)),
)
def as_argument_elements(self) -> ArgumentElements:
form_arguments = [config.MATCHES_ARGUMENT]
if self.full:
form_arguments.append(
option_syntax.option_syntax(config.MATCHES_FULL_OPTION.name))
return self.files_condition.as_argument_elements.with_first_line_preceded_by(
form_arguments)
def elements(self) -> List[WithToString]:
return [
option_syntax(
string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
self.transformer,
str(self.on_transformed),
]
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 name_reg_ex_pattern_matcher_of(pattern: str,
ignore_case: bool = False) -> str:
pattern_arg = pattern
if ' ' in pattern_arg and pattern_arg[0] not in token.QUOTE_CHARS:
pattern_arg = token.HARD_QUOTE_CHAR + pattern_arg + token.HARD_QUOTE_CHAR
args = [
parse_file_matcher.NAME_MATCHER_NAME,
option_syntax.option_syntax(parse_file_matcher.REG_EX_OPTION),
]
if ignore_case:
args.append(option_syntax.option_syntax(parse_regex.IGNORE_CASE_OPTION_NAME))
args.append(pattern_arg)
return ' '.join(args)
def base_name_reg_ex_pattern_matcher_of(regex_args: List[str]) -> str:
args = [
file_matcher.NAME_MATCHER_NAME,
option_syntax.option_syntax(parse_file_matcher.REG_EX_OPTION),
]
args += regex_args
return ' '.join(args)
def sparse_item_for(
self,
rel_option_type: RelOptionType) -> lists.HeaderContentListItem:
opt_info = REL_OPTIONS_MAP[rel_option_type]
return self.item_for(
option_syntax.option_syntax(opt_info._option_name),
opt_info.informative_name)
def _structure_name(full: bool) -> str:
elements = [
config.MATCHES_ARGUMENT,
syntax_elements.FILES_CONDITION_SYNTAX_ELEMENT.singular_name,
]
if full:
elements.insert(1, option_syntax.option_syntax(config.MATCHES_FULL_OPTION.name))
return ' '.join(elements)
def test_referenced_file_does_not_exist(self):
self._run(assignment_of('{file_option} {rel_home} non-existing-file'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_home=file_ref_syntax.REL_HOME_CASE_OPTION,
)),
Arrangement(),
Expectation(pre_validation_result=svh_assertions.is_validation_error(),
source=source_is_at_end)
)
def syntax_for_replace_transformer__custom(arguments: Arguments,
preserve_new_lines: bool = False
) -> Arguments:
matcher = names.REPLACE_TRANSFORMER_NAME
if preserve_new_lines:
matcher = ' '.join(
(matcher, option_syntax(names.PRESERVE_NEW_LINES_OPTION_NAME)))
return Arguments(matcher).followed_by(arguments)
def _empty_if_no_file_transformer_otherwise_selection(self) -> str:
if self._file_transformer:
return ' '.join([
option_syntax(
string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
self._file_transformer,
])
else:
return ''
def syntax_for_run(program: ArgumentElements,
ignore_exit_code: bool = False) -> Arguments:
st_arguments = [string_transformer.RUN_PROGRAM]
if ignore_exit_code:
st_arguments.append(
option_syntax(
string_transformer.WITH_IGNORED_EXIT_CODE_OPTION_NAME))
argument_elements = ArgumentElements(
st_arguments).append_to_first_and_following_lines(program)
return argument_elements.as_arguments
def test_referenced_file_is_a_directory(self):
self._run(assignment_of('{file_option} {rel_home} directory'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_home=file_ref_syntax.REL_HOME_CASE_OPTION,
)),
Arrangement(
hds_contents=case_home_dir_contents(DirContents([empty_dir('directory')]))
),
Expectation(pre_validation_result=svh_assertions.is_validation_error(),
source=source_is_at_end)
)
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)
def test_succeed_when_syntax_is_correct__with_relativity_option(self):
parser = sut.Parser()
for rel_option_type in sut.RELATIVITY_OPTIONS_CONFIGURATION.options.accepted_options:
option_string = long_option_syntax(REL_OPTIONS_MAP[rel_option_type].option_name.long)
instruction_argument = '{file_option} {rel_option} file'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_option=option_string)
with self.subTest(msg='Argument ' + instruction_argument):
for source in equivalent_source_variants__with_source_check(self,
assignment_str_of(instruction_argument)):
parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
def syntax_for_replace_transformer(regex_token_str: str,
replacement_token_str: str,
preserve_new_lines: bool = False) -> str:
matcher = [names.REPLACE_TRANSFORMER_NAME]
if preserve_new_lines:
matcher.append(option_syntax(names.PRESERVE_NEW_LINES_OPTION_NAME))
return ' '.join(matcher + [
regex_token_str,
replacement_token_str,
])
def reg_ex_args_list(pattern: str, ignore_case: bool = False) -> List[str]:
pattern_arg = pattern
if ' ' in pattern_arg and pattern_arg[0] not in token.QUOTE_CHARS:
pattern_arg = token.HARD_QUOTE_CHAR + pattern_arg + token.HARD_QUOTE_CHAR
args = []
if ignore_case:
args.append(
option_syntax.option_syntax(parse_regex.IGNORE_CASE_OPTION_NAME))
args.append(pattern_arg)
return args
def runTest(self):
from exactly_lib.test_case_utils.string_matcher.parse.parts.equality import \
EXPECTED_FILE_REL_OPT_ARG_CONFIG
expected_file_relativity_symbol = 'EXPECTED_RELATIVITY_SYMBOL_NAME'
file_ref_sym_tbl_entry_for_expected_file = data_symbol_utils.entry(
expected_file_relativity_symbol,
file_ref_resolvers.constant(file_refs.of_rel_option(self.relativity_of_expected_file(),
file_refs.empty_path_part())))
symbols_in_arrangement = symbol_tables.symbol_table_from_entries(
[file_ref_sym_tbl_entry_for_expected_file] +
self.rel_opt.symbols.entries_for_arrangement())
symbol_usage_expectation_for_expected_file = equals_symbol_reference_with_restriction_on_direct_target(
expected_file_relativity_symbol,
equals_file_ref_relativity_restriction(
FileRefRelativityRestriction(
EXPECTED_FILE_REL_OPT_ARG_CONFIG.options.accepted_relativity_variants)))
expected_symbol_usages = asrt.matches_sequence(
self.rel_opt.symbols.usage_expectation_assertions() +
[symbol_usage_expectation_for_expected_file])
populator_of_expected_files = home_and_sds_populators.HomeOrSdsPopulatorForRelOptionType(
self.relativity_of_expected_file(),
DirContents([File('expected.txt', 'expected contents')]))
populator_of_actual_files = self.rel_opt.populator_for_relativity_option_root(
DirContents([File('actual.txt', 'expected contents')]))
home_or_sds_contents_arrangement = home_and_sds_populators.multiple([
populator_of_actual_files,
populator_of_expected_files
])
self._check_single_instruction_line_with_source_variants(
args('{relativity_option} actual.txt {maybe_not} {equals} '
'{file_option} {rel_symbol_option} {rel_symbol_name} expected.txt',
relativity_option=self.rel_opt.option_argument,
maybe_not=self.not_opt.nothing__if_positive__not_option__if_negative,
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_symbol_name=expected_file_relativity_symbol),
ArrangementPostAct(
home_or_sds_contents=home_or_sds_contents_arrangement,
post_sds_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY,
symbols=symbols_in_arrangement,
),
Expectation(
main_result=self.not_opt.pass__if_positive__fail__if_negative,
symbol_usages=expected_symbol_usages,
),
)
def test_referenced_file_does_not_exist__rel_symbol__post_sds(self):
symbol_rel_opt = rel_opt_conf.symbol_conf_rel_any(
RelOptionType.REL_ACT,
'SYMBOL',
sut.RELATIVITY_OPTIONS_CONFIGURATION.options.accepted_relativity_variants)
self._run(assignment_of('{file_option} {relativity_option} file.txt'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
relativity_option=symbol_rel_opt.option_argument)),
Arrangement(
symbols=symbol_rel_opt.symbols.in_arrangement(),
),
Expectation(
post_validation_result=svh_assertions.is_validation_error(),
symbol_usages=symbol_rel_opt.symbols.usages_expectation(),
source=source_is_at_end),
)
def _simple_expressions(
) -> Sequence[NameAndValue[grammar.Primitive[StringMatcherSdv]]]:
equals_entry = NameAndValue(
matcher_options.EQUALS_ARGUMENT,
grammar.Primitive(equality.EqualsParser().parse_from_token_parser,
equality.Description()))
matches_entry = NameAndValue(
matcher_options.MATCHES_ARGUMENT,
grammar.Primitive(matches.parse, matches.Description()))
ret_val = [
NameAndValue(
matcher_options.EMPTY_ARGUMENT,
grammar.Primitive(emptieness.parse, emptieness.Description())),
equals_entry,
alias.entry(matcher_options.EQUALS_ARGUMENT__ALTERNATIVE,
equals_entry),
matches_entry,
alias.entry(matcher_options.MATCHES_ARGUMENT__ALTERNATIVE,
matches_entry),
]
quantification_setup = parse_quantified_matcher.GrammarSetup(
line_matches.line_matchers.ELEMENT_SETUP,
parse_line_matcher.parsers().simple,
)
ret_val += quantification_setup.quantification_grammar_expressions()
ret_val += [
NameAndValue(
matcher_options.NUM_LINES_ARGUMENT,
grammar.Primitive(num_lines.parse, num_lines.Description())),
NameAndValue(
matcher_options.RUN_PROGRAM_ARGUMENT,
grammar.Primitive(
run_program.parse,
run_program.SyntaxDescription(),
)),
NameAndValue(
option_syntax.option_syntax(
string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
grammar.Primitive(_parse_on_transformed,
_OnTransformedDescription())),
]
return ret_val
def construct(self, expectation_type: ExpectationType) -> str:
transformation = ''
if self.transformer:
transformation = option_syntax(WITH_TRANSFORMED_CONTENTS_OPTION_NAME) + ' ' + self.transformer
superfluous_args_str = self.superfluous_args_str
if superfluous_args_str:
superfluous_args_str = ' ' + superfluous_args_str
return '{transformation} {maybe_not} {num_lines} {operator} {operand}{superfluous_args_str}'.format(
transformation=transformation,
maybe_not=nothing__if_positive__not_option__if_negative(expectation_type),
num_lines=matcher_options.NUM_LINES_ARGUMENT,
operator=self.operator,
operand=self.operand,
superfluous_args_str=superfluous_args_str,
)
def test_with_symbol_references(self):
# ARRANGE #
symbol_relativity = RelOptionType.REL_TMP
default_relativity = RelOptionType.REL_RESULT
accepted_path_relativity_variants = PathRelativityVariants({default_relativity,
symbol_relativity},
absolute=False)
rel_opt_arg_conf = RelOptionArgumentConfiguration(
RelOptionsConfiguration(accepted_path_relativity_variants,
default_relativity),
'ARG_SYNTAX_NAME',
False
)
symbol_path_suffix = 'symbol-path-suffix'
symbol = NameAndValue('path_symbol',
file_refs.of_rel_option(
symbol_relativity,
concrete_path_parts.fixed_path_parts(symbol_path_suffix)))
file_name = 'file'
source = remaining_source_lines(
['{file_option} {rel_symbol_option} {file_name} following args'.format(
rel_symbol_option=relativity_arguments.rel_symbol_arg_str(symbol.name),
file_option=option_syntax(sut.FILE_ARGUMENT_OPTION),
file_name=file_name,
),
'following line',
])
# EXPECTATION #
expectation = ExpectedFileRef(
file_ref_value=file_refs.of_rel_option(symbol_relativity,
concrete_path_parts.fixed_path_parts([symbol_path_suffix,
file_name])),
common=CommonExpectation(
symbol_references=[SymbolReference(symbol.name,
file_ref_reference_restrictions(
accepted_path_relativity_variants))],
source=asrt_source.assert_source(current_line_number=asrt.equals(1),
remaining_part_of_current_line=asrt.equals(
'following args')),
symbol_table=singleton_symbol_table_2(symbol.name,
file_ref_constant_container(symbol.value)))
)
# ACT & ASSERT #
_expect_file_ref(self, source, expectation,
rel_opt_arg_conf)
def _builtin(symbol_name: str, relativity: RelOptionType) -> BuiltinSymbol:
tp = TextParser({
'relativity_option':
formatting.cli_argument_option_string(
option_syntax.option_syntax(
relative_path_options.REL_OPTIONS_MAP[relativity]._option_name)
)
})
return BuiltinSymbol(
symbol_name,
ValueType.PATH,
__sdv_of(relativity),
CustomSymbolDocumentation(
SYMBOL_DESCRIPTION.as_single_line_description_str(symbol_name),
tp.section_contents(_DESCRIPTION),
),
)
def construct(self, expectation_type: ExpectationType) -> str:
transformation = ''
if self.transformer:
transformation = ' '.join([
option_syntax(string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
self.transformer
])
superfluous_args_str = self.superfluous_args_str
if superfluous_args_str:
superfluous_args_str = ' ' + superfluous_args_str
return '{transformation} {maybe_not} {num_lines} {operator} {operand}{superfluous_args_str}'.format(
transformation=transformation,
maybe_not=nothing__if_positive__not_option__if_negative(expectation_type),
num_lines=matcher_options.NUM_LINES_ARGUMENT,
operator=self.operator,
operand=self.operand,
superfluous_args_str=superfluous_args_str,
)
def test_invalid_syntax(self):
test_cases = [
source4(''),
assignment_of('string superfluous-argument'),
assignment_of('{file_option} {rel_home} file superfluous-argument'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_home=file_ref_syntax.REL_HOME_CASE_OPTION,
)),
assignment_of('<<MARKER superfluous argument',
['single line',
'MARKER']),
assignment_of('<<MARKER ',
['single line',
'NOT_MARKER']),
]
parser = sut.Parser()
for source in test_cases:
with self.subTest(msg='first line of source=' + source.remaining_part_of_current_line):
with self.assertRaises(SingleInstructionInvalidArgumentException):
parser.parse(ARBITRARY_FS_LOCATION_INFO, source)
def test_without_symbol_references(self):
file_name = 'file'
source = remaining_source_lines(
['{file_option} {file_name} following args'.format(
file_option=option_syntax(sut.FILE_ARGUMENT_OPTION),
file_name=file_name,
),
'following line',
])
expectation = ExpectedFileRef(
file_ref_value=file_refs.of_rel_option(sut.CONFIGURATION.options.default_option,
concrete_path_parts.fixed_path_parts(file_name)),
common=CommonExpectation(
symbol_references=[],
source=asrt_source.assert_source(current_line_number=asrt.equals(1),
remaining_part_of_current_line=asrt.equals(
'following args')))
)
_expect_file_ref(self, source, expectation)
def test_parse_SHOULD_fail_WHEN_relativity_is_not_accepted(self):
accepted_option_type = RelOptionType.REL_TMP
unaccepted_option_type_string_conf = OptionStringConfigurationForRelativityOption(RelOptionType.REL_RESULT)
accepted_path_relativity_variants = PathRelativityVariants({accepted_option_type},
absolute=False)
rel_opt_arg_conf = RelOptionArgumentConfiguration(
RelOptionsConfiguration(accepted_path_relativity_variants,
accepted_option_type),
'ARG_SYNTAX_NAME',
False
)
file_name = 'file'
source = remaining_source_lines(
['{file_option} {unaccepted_rel_option} {file_name}'.format(
file_option=option_syntax(sut.FILE_ARGUMENT_OPTION),
unaccepted_rel_option=unaccepted_option_type_string_conf.option_string,
file_name=file_name,
),
'following line',
])
with self.assertRaises(SingleInstructionInvalidArgumentException):
sut.parse_from_parse_source(source, rel_opt_arg_conf)
def __init__(self):
super().__init__(TypeCategory.LOGIC,
syntax_elements.STRING_MATCHER_SYNTAX_ELEMENT)
self.matcher_element_name = instruction_arguments.STRING_MATCHER_PRIMITIVE_SYNTAX_ELEMENT
self.expected_file_arg = a.Option(FILE_ARGUMENT_OPTION,
_EXPECTED_PATH_NAME)
self.string_or_here_doc_or_file_arg = StringOrHereDocOrFile(
_EXPECTED_PATH_NAME,
_RELATIVITY_OF_EXPECTED_PATH_NAME,
EXPECTED_FILE_REL_OPT_ARG_CONFIG,
the_path_of('the file that contains the expected contents.'))
self._parser = TextParser({
'symbol_concept': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
'expected_file_arg': _EXPECTED_PATH_NAME,
'any': instruction_arguments.EXISTS_QUANTIFIER_ARGUMENT,
'every': instruction_arguments.ALL_QUANTIFIER_ARGUMENT,
'LINE_MATCHER': instruction_arguments.LINE_MATCHER.name,
'HERE_DOCUMENT': formatting.syntax_element_(syntax_elements.HERE_DOCUMENT_SYNTAX_ELEMENT),
'INTEGER_COMPARISON': syntax_elements.INTEGER_COMPARISON_SYNTAX_ELEMENT.singular_name,
'REGEX': syntax_elements.REGEX_SYNTAX_ELEMENT.singular_name,
'full_regex_match': option_syntax.option_syntax(matcher_options.FULL_MATCH_ARGUMENT_OPTION),
'this_type': formatting.symbol_type(types.STRING_MATCHER_TYPE_INFO.singular_name),
})
from exactly_lib.tcfs.path_relativity import DirectoryStructurePartition
from exactly_lib.tcfs.tcds import TestCaseDs
from exactly_lib.type_val_deps.dep_variants.ddv.ddv_validation import DdvValidator
from exactly_lib.type_val_deps.types.string_.string_ddv import StringDdv
from exactly_lib.type_val_deps.types.string_.string_sdv import StringSdv
from exactly_lib.util.cli_syntax import option_syntax
from exactly_lib.util.cli_syntax.elements import argument as a
from exactly_lib.util.description_tree import details
from exactly_lib.util.description_tree.renderer import DetailsRenderer
from exactly_lib.util.render import strings as string_rendering
from exactly_lib.util.str_ import str_constructor
from exactly_lib.util.symbol_table import SymbolTable
IGNORE_CASE_OPTION_NAME = a.OptionName(long_name='ignore-case')
IGNORE_CASE_OPTION = option_syntax.option_syntax(IGNORE_CASE_OPTION_NAME)
class ParserOfRegex(ParserFromTokenParserBase[RegexSdv]):
def __init__(self):
super().__init__(False, False)
self._string_parser = parse_rich_string.RichStringParser()
def parse_from_token_parser(self, token_parser: TokenParser) -> RegexSdv:
token_parser.require_has_valid_head_token(
syntax_elements.REGEX_SYNTAX_ELEMENT.singular_name)
is_ignore_case = token_parser.consume_and_handle_optional_option(
False, lambda x: True, IGNORE_CASE_OPTION_NAME)
regex_pattern = self._string_parser.parse_from_token_parser(
token_parser)
return _RegexSdv(is_ignore_case, regex_pattern)
def selection_arguments_for_matcher(matcher: str) -> str:
return (option_syntax.option_syntax(instruction_arguments.SELECTION_OPTION.name) +
' ' +
matcher)
def strip_trailing_space() -> str:
return ' '.join((
names.STRIP_SPACE,
option_syntax(names.STRIP_TRAILING_SPACE_OPTION_NAME),
))
def strip_trailing_new_lines() -> str:
return ' '.join((
names.STRIP_SPACE,
option_syntax(names.STRIP_TRAILING_NEW_LINES_OPTION_NAME),
))
def __str__(self) -> str:
return option_syntax.option_syntax(self.option_name)
def option_name_text(self) -> StringText:
return syntax_text(option_syntax(self._option_name))
def option_name_text(self) -> StringText:
return syntax_text(option_syntax(self._option_name))
def arguments(self) -> List[str]:
return [
option_syntax.option_syntax(
file_matcher.PROGRAM_ARG_OPTION__MARKER.name), self.marker
]
def argument_option(name: a.OptionName) -> str:
return option_syntax.option_syntax(name)
def arguments_for_transformer_option(transformer_expression: str) -> List[str]:
return [
option_syntax(
string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
transformer_expression,
]
def _empty_if_no_file_transformer_otherwise_selection(self) -> str:
if self._file_transformer:
return option_syntax(WITH_TRANSFORMED_CONTENTS_OPTION_NAME) + ' ' + self._file_transformer
else:
return ''
from exactly_lib.symbol.logic.program.string_or_file import SourceType
from exactly_lib.symbol.symbol_usage import SymbolReference
from exactly_lib.test_case.pre_or_post_value_validation import PreOrPostSdsValueValidator
from exactly_lib.test_case_file_structure.home_and_sds import HomeAndSds
from exactly_lib.test_case_file_structure.home_directory_structure import HomeDirectoryStructure
from exactly_lib.test_case_file_structure.path_relativity import DirectoryStructurePartition
from exactly_lib.test_case_utils.parse.parse_here_doc_or_file_ref import parse_string_or_here_doc_from_token_parser
from exactly_lib.test_case_utils.regex.regex_value import RegexResolver, RegexValue
from exactly_lib.type_system.data.string_value import StringValue
from exactly_lib.util.cli_syntax import option_syntax
from exactly_lib.util.cli_syntax.elements import argument as a
from exactly_lib.util.symbol_table import SymbolTable
IGNORE_CASE_OPTION_NAME = a.OptionName(long_name='ignore-case')
IGNORE_CASE_OPTION = option_syntax.option_syntax(IGNORE_CASE_OPTION_NAME)
MISSING_REGEX_ARGUMENT_ERR_MSG = 'Missing ' + syntax_elements.REGEX_SYNTAX_ELEMENT.argument.name
MISSING_STRING_ARGUMENT_FOR_REGEX_ERR_MSG = 'Missing {} argument for {}'.format(
syntax_elements.STRING_SYNTAX_ELEMENT.argument.name,
syntax_elements.REGEX_SYNTAX_ELEMENT.argument.name,
)
def regex_parser() -> Parser[RegexResolver]:
return _PARSER
def parse_regex(parser: TokenParser,
must_be_on_same_line: bool = True,
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 syntax_for_transformer_option(transformer_expression: str) -> str:
return ' '.join([
option_syntax(instruction_arguments.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
transformer_expression,
])
def arguments(self) -> List[str]:
return [
option_syntax.option_syntax(
file_matcher.PROGRAM_ARG_OPTION__LAST.name)
]
def __str__(self) -> str:
return option_syntax.option_syntax(self.option_name)
def syntax_for_transformer_option(transformer_expression: str) -> str:
return ' '.join([
option_syntax(
string_transformer.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
transformer_expression,
])
def arguments_for_transformer_option(transformer_expression: str) -> List[str]:
return [
option_syntax(instruction_arguments.WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
transformer_expression,
]
def to_upper_case() -> str:
return ' '.join((
names.CHARACTER_CASE,
option_syntax(names.CHARACTER_CASE_TO_UPPER_OPTION_NAME),
))
def item(option: a.OptionName,
description_template: str) -> lists.HeaderContentListItem:
return docs.list_item(
doc_format.syntax_text(option_syntax.option_syntax(option)),
tp.fnap(description_template))
def sparse_item_for(self, rel_option_type: RelOptionType) -> lists.HeaderContentListItem:
opt_info = REL_OPTIONS_MAP[rel_option_type]
return self.item_for(option_syntax.option_syntax(opt_info.option_name),
opt_info.informative_name)
from exactly_lib.test_case_utils.err_msg import diff_msg_utils
from exactly_lib.test_case_utils.err_msg.path_description import path_value_with_relativity_name_prefix
from exactly_lib.test_case_utils.parse import parse_here_document, parse_file_ref
from exactly_lib.test_case_utils.parse import parse_string
from exactly_lib.test_case_utils.parse.rel_opts_configuration import RelOptionArgumentConfiguration
from exactly_lib.type_system.error_message import ErrorMessageResolvingEnvironment
from exactly_lib.util.cli_syntax.elements import argument as a
from exactly_lib.util.cli_syntax.option_syntax import option_syntax
CONFIGURATION = parse_file_ref.ALL_REL_OPTIONS_CONFIG
FILE_ARGUMENT_OPTION = a.OptionName(long_name='file')
MISSING_SOURCE = 'Missing argument ({string}, {file_ref} or {here_doc})'.format(
string=instruction_arguments.STRING.name,
file_ref=option_syntax(FILE_ARGUMENT_OPTION),
here_doc=instruction_arguments.HERE_DOCUMENT.name, )
def parse_from_parse_source(source: ParseSource,
conf: RelOptionArgumentConfiguration = CONFIGURATION) -> StringOrFileRefResolver:
with from_parse_source(source,
consume_last_line_if_is_at_eol_after_parse=False) as token_parser:
ret_val = parse_from_token_parser(token_parser, conf)
if ret_val.source_type is SourceType.HERE_DOC:
if source.is_at_eol:
source.consume_current_line()
return ret_val
def parse_from_token_parser(token_parser: TokenParser,
return '{any_or_every} {line} {quantifier_separator} {condition}'.format(
any_or_every=instruction_arguments.QUANTIFIER_ARGUMENTS[self.quantifier],
line=matcher_options.LINE_ARGUMENT,
quantifier_separator=instruction_arguments.QUANTIFICATION_SEPARATOR_ARGUMENT,
condition=self._condition,
)
def args(arg_str: str, **kwargs) -> str:
if kwargs:
format_map = dict(list(_FORMAT_MAP.items()) + list(kwargs.items()))
return arg_str.format_map(format_map)
return arg_str.format_map(_FORMAT_MAP)
FULL_MATCH_ARGUMENT = option_syntax(matcher_options.FULL_MATCH_ARGUMENT_OPTION)
_FORMAT_MAP = {
'any': instruction_arguments.EXISTS_QUANTIFIER_ARGUMENT,
'every': instruction_arguments.ALL_QUANTIFIER_ARGUMENT,
'empty': matcher_options.EMPTY_ARGUMENT,
'equals': matcher_options.EQUALS_ARGUMENT,
'matches': matcher_options.MATCHES_ARGUMENT,
'file_option': option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
'full_match': FULL_MATCH_ARGUMENT,
'not': matcher_options.NOT_ARGUMENT,
'transform_option': option_syntax(WITH_TRANSFORMED_CONTENTS_OPTION_NAME),
'rel_home_case_option': file_ref_texts.REL_HOME_CASE_OPTION,
'rel_cwd_option': file_ref_texts.REL_CWD_OPTION,
'rel_tmp_option': file_ref_texts.REL_TMP_OPTION,
'rel_symbol_option': file_ref_texts.REL_symbol_OPTION,
