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,