def _grammar( parser_of_nested: ParserFromTokens[FilesSourceSdv] ) -> _expr_grammar.Grammar[FilesSourceSdv]: copy_src_dir_arg_conf = defs.src_dir_path_argument( _COPY__SRC_PATH_ARG.singular_name) return _expr_grammar.Grammar( concept=_GRAMMAR_CONCEPT, mk_reference=reference.ReferenceSdv, primitives=( NameAndValue( syntax.FILE_LIST_BEGIN, _expr_grammar.Primitive( parse_file_list.Parser(parser_of_nested).parse, _DESCRIPTION_OF_FILE_LIST, )), NameAndValue( syntax.COPY_CONTENTS_OF_EXISTING_DIR, _expr_grammar.Primitive( parse_copy.Parser(copy_src_dir_arg_conf).parse, _DESCRIPTION_OF_COPY, )), ), infix_operators_in_order_of_increasing_precedence=(), prefix_operators=(), custom_reserved_words=tuple(syntax.FILE_TYPE_TOKENS.values()))
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
def entry( alias_name: str, aliased: NameAndValue[grammar.Primitive[T]] ) -> NameAndValue[grammar.Primitive[T]]: return NameAndValue( alias_name, grammar.Primitive( aliased.value.parse_arguments, _Description(aliased.name, aliased.value.description())))
def quantification_grammar_expressions(self, ) -> Sequence[NameAndValue[grammar.Primitive[MatcherSdv[MODEL]]]]: return ( NameAndValue( logic.ALL_QUANTIFIER_ARGUMENT, grammar.Primitive( self.parse_all, QuantificationDoc(Quantifier.ALL, self._setup.rendering.type_name, self._setup.rendering.element_matcher_syntax_info) ) ), NameAndValue( logic.EXISTS_QUANTIFIER_ARGUMENT, grammar.Primitive( self.parse_exists, QuantificationDoc(Quantifier.EXISTS, self._setup.rendering.type_name, self._setup.rendering.element_matcher_syntax_info) ) ), )
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
@property 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()] ) ] @property def description_rest(self) -> Sequence[ParagraphItem]: return _TP.fnap(_DESCRIPTION) CONSTANT_PRIMITIVE = NameAndValue( logic.CONSTANT_MATCHER, grammar.Primitive( parse_constant, _Description() ) ) _TP = TextParser({ 'false': logic.BOOLEANS[False], 'true': logic.BOOLEANS[True], }) _DESCRIPTION = """\ Unconditionally {false} or {true}. """
syntax_elements.INTEGER_MATCHER_SYNTAX_ELEMENT. cross_reference_target ] _CONCEPT = grammar.Concept( types.LINE_MATCHER_TYPE_INFO.name, types.LINE_MATCHER_TYPE_INFO.identifier, syntax_elements.LINE_MATCHER_SYNTAX_ELEMENT.argument, ) GRAMMAR = standard_expression_grammar.new_grammar( _CONCEPT, model=matcher_model.LINE_MATCHER_MODEL, value_type=ValueType.LINE_MATCHER, simple_expressions=( NameAndValue( line_matcher.CONTENTS_MATCHER_NAME, grammar.Primitive(contents_parse.PARSER.parse, contents_doc.SyntaxDescription())), NameAndValue( line_matcher.LINE_NUMBER_MATCHER_NAME, grammar.Primitive(line_number.parse_line_number, _LineNumberSyntaxDescription())), ), model_freezer=combinator_matchers.no_op_freezer, ) _PARSERS_FOR_MUST_BE_ON_CURRENT_LINE = ep.parsers_for_must_be_on_current_line( GRAMMAR)
GRAMMAR = standard_expression_grammar.new_grammar( concept=grammar.Concept( name=types.FILE_MATCHER_TYPE_INFO.name, type_system_type_name=types.FILE_MATCHER_TYPE_INFO.identifier, syntax_element_name=syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.argument, ), description=_description, model=matcher_model.FILE_MATCHER_MODEL, value_type=ValueType.FILE_MATCHER, simple_expressions=( NameAndValue( file_matcher.TYPE_MATCHER_NAME, grammar.Primitive( _parse_type_matcher, _TypeSyntaxDescription() ) ), NameAndValue( file_check_properties.REGULAR_FILE_CONTENTS, grammar.Primitive( _parse_regular_file_contents, file_contents_utils.FileContentsSyntaxDescription( file_or_dir_contents_doc.REGULAR_FILE_DOCUMENTATION_SETUP ) ) ), NameAndValue( file_check_properties.DIR_CONTENTS,
def prefix_op( name: str, mk_expr: Callable[[Expr], Expr]) -> NameAndValue[grammar.PrefixOperator[Expr]]: return NameAndValue( name, grammar.PrefixOperator(mk_expr, ConstantOperatorDescription([]))) PRIMITIVE_EXPRESSIONS__EXCEPT_RECURSIVE = ( NameAndValue( PRIMITIVE_WITH_ARG, grammar.Primitive( parse_primitive_with_arg, ConstantPrimitiveDescription( [], [], [SyntaxElementDescription(PRIMITIVE_WITH_ARG + '-SED', ())], [CROSS_REF_ID]))), NameAndValue( PRIMITIVE_SANS_ARG, grammar.Primitive(parse_primitive_sans_arg, ConstantPrimitiveDescription([], []))), ) PRIMITIVE_EXPRESSIONS__INCLUDING_RECURSIVE = ( list(PRIMITIVE_EXPRESSIONS__EXCEPT_RECURSIVE) + [ NameAndValue( PRIMITIVE_RECURSIVE, grammar.Primitive( parse_recursive_primitive_of_grammar_w_all_components, ConstantPrimitiveDescription([], [])))
_MESSAGE_FACTORY = MessageFactory({ 'FILES_CONDITION': syntax_elements.FILES_CONDITION_SYNTAX_ELEMENT.singular_name, }) _FILE_NAME_OR_SET_END = 'FILE-NAME or ' + syntax.END_BRACE__FOR_FORMAT_STRINGS _HEADER = """\ Reading {FILES_CONDITION}""" _MULTIPLE_FILES_ON_SINGLE_LINE = 'There can only be one file per line.' GRAMMAR = grammar.Grammar( concept=grammar.Concept( name=types.FILES_CONDITION_TYPE_INFO.name, type_system_type_name=types.FILES_CONDITION_TYPE_INFO.identifier, syntax_element_name=syntax_elements.FILES_CONDITION_SYNTAX_ELEMENT.argument, ), mk_reference=files_conditions.new_reference, primitives=( NameAndValue( syntax.LITERAL_BEGIN, grammar.Primitive(_parse_constant, documentation.ConstantSyntaxDescription()) ), ), infix_operators_in_order_of_increasing_precedence=(), prefix_operators=(), ) _PARSERS_FOR_MUST_BE_ON_CURRENT_LINE = ep.parsers_for_must_be_on_current_line(GRAMMAR)
syntax_elements.STRING_TRANSFORMER_SYNTAX_ELEMENT.argument, ) def _mk_reference(name: str) -> StringTransformerSdv: return sdvs.StringTransformerSdvReference(name) GRAMMAR = grammar.Grammar( _CONCEPT, mk_reference=_mk_reference, primitives=( NameAndValue( names.FILTER_TRANSFORMER_NAME, grammar.Primitive( parse_filter.Parser(names.FILTER_TRANSFORMER_NAME).parse, parse_filter.SyntaxDescription(), )), NameAndValue( names.GREP_TRANSFORMER_NAME, grammar.Primitive( parse_filter.GrepShortcutParser( names.FILTER_TRANSFORMER_NAME).parse, parse_filter.GrepShortcutSyntaxDescription( names.FILTER_TRANSFORMER_NAME), )), NameAndValue( names.REPLACE_TRANSFORMER_NAME, grammar.Primitive(_replace_setup.ParserOfReplace().parse, _replace_setup.SyntaxDescription())), NameAndValue( names.CHARACTER_CASE,
INFIX_OPERATOR_DESCRIPTION = ConstantInfixOperatorDescription([], [], [CROSS_REF_ID]) def _mk_reference(name: str) -> Expr: return Reference(name) GRAMMAR = grammar.Grammar( concept=CONCEPT, mk_reference=_mk_reference, primitives=(NameAndValue( PRIMITIVE_WITH_ARG, grammar.Primitive( parse_primitive, ConstantPrimitiveDescription( [], [], [SyntaxElementDescription(PRIMITIVE_WITH_ARG + '-SED', ())], [CROSS_REF_ID]))), ), prefix_operators=[ NameAndValue( POP, grammar.PrefixOperator(PrefixOp, ConstantOperatorDescription([]))), ], infix_operators_in_order_of_increasing_precedence=[ [ NameAndValue( IOP_2u, grammar.InfixOperator(InfixOp2u, INFIX_OPERATOR_DESCRIPTION)), NameAndValue( IOP_2v, grammar.InfixOperator(InfixOp2v, INFIX_OPERATOR_DESCRIPTION)),
def see_also_targets(self) -> Sequence[SeeAlsoTarget]: return syntax_elements.INTEGER_SYNTAX_ELEMENT.cross_reference_target, GRAMMAR = standard_expression_grammar.new_grammar( concept=grammar.Concept( name=types.INTEGER_MATCHER_TYPE_INFO.name, type_system_type_name=types.INTEGER_MATCHER_TYPE_INFO.identifier, syntax_element_name=syntax_elements.INTEGER_MATCHER_SYNTAX_ELEMENT. argument, ), model=matcher_model.INTEGER_MATCHER_MODEL, value_type=ValueType.INTEGER_MATCHER, simple_expressions=[ NameAndValue( operator.name, grammar.Primitive( _ComparisonParser(operator).parse, _ComparisonSyntaxDescription(operator), )) for operator in comparators.ALL_OPERATORS ], model_freezer=combinator_matchers.no_op_freezer, ) _PARSERS_FOR_MUST_BE_ON_CURRENT_LINE = ep.parsers_for_must_be_on_current_line( GRAMMAR) _COMPARISON_DESCRIPTION = """\ Matches {model:s} {operator} {LHS}. """