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}.
"""
