def __init__(self):
super().__init__(TypeCategory.DATA,
syntax_elements.PATH_SYNTAX_ELEMENT)
self._string_name = a.Named(syntax_elements.STRING_SYNTAX_ELEMENT.singular_name)
self._relativity_name = instruction_arguments.RELATIVITY_ARGUMENT
path_type_symbol = 'MY_PATH_SYMBOL'
self._parser = TextParser({
'RELATIVITY_OPTION': self._relativity_name.name,
'PATH_STRING': self._string_name.name,
'posix_syntax': documentation_text.POSIX_SYNTAX,
'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
'string_syntax_element': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name,
'cd': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
'SYMBOL_NAME': syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument.name,
'define_symbol': formatting.InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME),
'current_directory': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'REFERENCED_SYMBOL': path_type_symbol,
'SYMBOL_REFERENCE': symbol_reference_syntax_for_name(path_type_symbol),
'def_of_path_symbol': define_symbol.def_syntax_string(ValueType.PATH, path_type_symbol, '...'),
'ref_of_path_symbol': '... ' + str(PurePosixPath(symbol_reference_syntax_for_name(path_type_symbol)) /
'a' / 'path' / 'relative' / 'to' / path_type_symbol),
})
def __init__(self):
super().__init__(syntax_elements.PATH_SYNTAX_ELEMENT)
self._file_name = instruction_arguments.FILE_NAME_STRING
self._relativity_name = instruction_arguments.RELATIVITY_ARGUMENT
path_type_symbol = 'MY_PATH_SYMBOL'
self._parser = TextParser({
'Note': headers.NOTE_LINE_HEADER,
'RELATIVITY_OPTION': self._relativity_name.name,
'PATH_STRING': self._file_name.name,
'posix_syntax': documentation_text.POSIX_SYNTAX,
'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular),
'string_type_plain': types.STRING_TYPE_INFO.name,
'reserved_word': misc_texts.RESERVED_WORD_NAME,
'reserved_word_list_str': ', '.join([formatting.keyword(x) for x in reserved_words.RESERVED_TOKENS]),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
'string_syntax_element': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name,
'cd': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
'SYMBOL_NAME': syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument.name,
'define_symbol': formatting.InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME),
'current_directory': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'REFERENCED_SYMBOL': path_type_symbol,
'SYMBOL_REFERENCE': symbol_reference_syntax_for_name(path_type_symbol),
'def_of_path_symbol': define_symbol.def_syntax_string(ValueType.PATH, path_type_symbol, '...'),
'ref_of_path_symbol': '... ' + str(PurePosixPath(symbol_reference_syntax_for_name(path_type_symbol)) /
'a' / 'path' / 'relative' / 'to' / path_type_symbol),
})
def __init__(self):
super().__init__(TypeCategory.DATA,
syntax_elements.LIST_SYNTAX_ELEMENT)
self._tp = TextParser({
'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular),
'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular),
'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
})
def list_syntax_description(
list_type: NameWithGenderWithFormatting) -> List[ParagraphItem]:
tp = TextParser({
'list_type':
list_type,
'r_paren':
formatting.keyword(reserved_words.PAREN_END),
'line_continuation':
formatting.keyword(_list_defs.CONTINUATION_TOKEN),
'end_of_line':
defs.END_OF_LINE,
})
return tp.fnap(_DESCRIPTION)
def plain_symbol_name_is_reserved_word(self, primitive_name: str) -> str:
formatter = StringFormatter({
'reserved_word': formatting.misc_name_with_formatting(misc_texts.RESERVED_WORD_NAME),
'syntax_element': self._grammar.concept.syntax_element.name,
'actual': formatting.keyword(primitive_name),
})
lines = [formatter.format(self._RESERVED_WORD__HEADER),
'',
formatter.format(self._RESERVED_WORD__LIST_HEADER),
'']
lines += [
self._INDENT + formatting.keyword(reserved_word)
for reserved_word in sorted(self._grammar.custom_reserved_words)
]
return '\n'.join(lines)
def _known_primitives_and_prefix_operators(self) -> List[str]:
ret_val = [
formatting.keyword(primitive.name)
for primitive in self._grammar.primitives__seq
]
ret_val += [
formatting.keyword(prefix_operator.name)
for prefix_operator in self._grammar.prefix_operators__seq
]
ret_val += [
syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name,
syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.singular_name,
formatting.keyword('('),
]
return ret_val
def __init__(self, name: str):
super().__init__(name)
self._tp = TextParser({
'program_name': program_info.PROGRAM_NAME,
'phase': phase_names.PHASE_NAME_DICTIONARY,
'setup': phase_infos.SETUP.name,
'act': phase_infos.ACT.name,
'action_to_check': concepts.ACTION_TO_CHECK_CONCEPT_INFO.name,
'home_directory': formatting.conf_param_(conf_params.HDS_CASE_DIRECTORY_CONF_PARAM_INFO),
'sandbox': formatting.concept_(concepts.SDS_CONCEPT_INFO),
'result_dir': tc_fs.SDS_RESULT_INFO.identifier,
'actor_option': OPTION_FOR_ACTOR,
'actor': concepts.ACTOR_CONCEPT_INFO.name,
'actor_instruction': formatting.InstructionName(ACTOR_INSTRUCTION_NAME),
'default_actor': actors.DEFAULT_ACTOR_SINGLE_LINE_VALUE,
'null_actor': formatting.entity_(actors.NULL_ACTOR),
'os_process': misc_texts.OS_PROCESS_NAME,
'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name,
'stdin_instruction': InstructionName(instruction_names.CONTENTS_OF_STDIN_INSTRUCTION_NAME),
'env_instruction': InstructionName(instruction_names.ENV_VAR_INSTRUCTION_NAME),
'timeout': concepts.TIMEOUT_CONCEPT_INFO.name,
'timeout_default': concepts.TIMEOUT_CONCEPT_INFO.default,
'timeout_instruction': InstructionName(instruction_names.TIMEOUT_INSTRUCTION_NAME),
'conf_param': concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.name,
'env_var': concepts.ENVIRONMENT_VARIABLE_CONCEPT_INFO.name,
'PROGRAM': syntax_elements.PROGRAM_SYNTAX_ELEMENT.singular_name,
'stdin': misc_texts.STDIN,
'directive': concepts.DIRECTIVE_CONCEPT_INFO.name,
'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
def __init__(self, name_of_aliased: str):
target_components = (name_of_aliased,
line_matcher_primitives.CONTENTS_MATCHER_NAME,
sm_matcher_options.MATCHES_ARGUMENT)
self._tp = TextParser({
'grep_shortcut_target':
formatting.keyword(' '.join(target_components)),
})
def cd_instruction_section_on_def_instruction() -> List[ParagraphItem]:
tp = TextParser({
'current_directory_concept': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'def_instruction': InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME),
'symbol_concept': formatting.concept(concepts.SYMBOL_CONCEPT_INFO.singular_name),
'rel_cd_option': formatting.cli_option(file_ref.REL_CWD_OPTION),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
})
return tp.fnap(_CD_INSTRUCTION_SECTION_ON_DEF_INSTRUCTION)
def path_type_path_rendering() -> SectionItem:
tp = TextParser({
'current_directory_concept': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO),
'def_instruction': InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME),
'symbol_concept': formatting.concept(concepts.SYMBOL_CONCEPT_INFO.singular_name),
'rel_cd_option': formatting.cli_option(file_ref.REL_CWD_OPTION),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
})
return Section(tp.text(_PATH_TYPE_PATH_RENDERING_DESCRIPTION_HEADER),
tp.section_contents(_PATH_TYPE_PATH_RENDERING_DESCRIPTION))
def __init__(self):
super().__init__(TypeCategory.DATA,
syntax_elements.STRING_SYNTAX_ELEMENT)
self._tp = TextParser({
'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular),
'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
'CHR': 'CHARACTER',
'SOFT_Q': token.SOFT_QUOTE_CHAR,
'HARD_Q': token.HARD_QUOTE_CHAR,
'soft_quotes': formatting.concept(token.SOFT_QUOTE_NAME.plural),
'hard_quotes': formatting.concept(token.HARD_QUOTE_NAME.plural),
'SYMBOL_REFERENCE_SYNTAX_ELEMENT': syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name,
'REL_CD_OPTION': file_ref.REL_CWD_OPTION,
})
def _text_parser() -> TextParser:
return TextParser({
'phase_declaration_for_NAME':
section_header('NAME'),
'instr':
AnyInstructionNameDictionary(),
'instruction':
concepts.INSTRUCTION_CONCEPT_INFO.name,
'instruction_description':
defs.INSTRUCTION_DESCRIPTION,
'description_delimiter':
defs.DESCRIPTION_DELIMITER,
'description_delimiter_char_name':
defs.DESCRIPTION_DELIMITER_CHAR_NAME,
'default_phase':
phase_names.PHASE_NAME_DICTIONARY[DEFAULT_PHASE.identifier].syntax,
'phase':
phase_names.PHASE_NAME_DICTIONARY,
'actor':
formatting.concept_(ACTOR_CONCEPT_INFO),
'CONTENTS_EQUALS_ARGUMENT':
contents_opts.EQUALS_ARGUMENT,
'CONTENTS_EMPTY_ARGUMENT':
contents_opts.EMPTY_ARGUMENT,
'line_comment_char':
LINE_COMMENT_MARKER,
'file_inclusion_directive_in_text':
formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
'file_inclusion_directive':
directives.INCLUDING_DIRECTIVE_INFO.singular_name,
'shell_command':
formatting.misc_name_with_formatting(misc_texts.SHELL_COMMAND),
'plain_string':
misc_texts.PLAIN_STRING,
'instruction__shell_cmd_line':
instruction_names.SHELL_INSTRUCTION_NAME,
'instruction__stdout':
instruction_names.CONTENTS_OF_STDOUT_INSTRUCTION_NAME,
'instruction__stderr':
instruction_names.CONTENTS_OF_STDERR_INSTRUCTION_NAME,
'instruction__exit_code':
instruction_names.EXIT_CODE_INSTRUCTION_NAME,
'INT_EQUALS_OPERATOR':
comparators.EQ.name,
'HERE_DOCUMENT_MARKER_PREFIX':
string.HERE_DOCUMENT_MARKER_PREFIX,
'MARKER':
'EOF',
'sds_result_dir':
sds.SUB_DIRECTORY__RESULT,
'sds_stdout_file':
sds.RESULT_FILE__STDOUT,
})
def __init__(self,
name: str,
instruction_set: Optional[SectionInstructionSet]):
"""
:param instruction_set: None if this phase does not have instructions.
"""
super().__init__(TestCasePhaseInfo(name))
self._instruction_set = instruction_set
self.__tp = TextParser({
'directive': concepts.DIRECTIVE_CONCEPT_INFO.name,
'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
def __init__(self):
super().__init__(syntax_elements.STRING_SYNTAX_ELEMENT)
the_string_type = 'the ' + types.STRING_TYPE_INFO.singular_name
non_str_types_w_str_conversion = value_type.sorted_types(
set(value_type.VALUE_TYPES_W_STR_RENDERING) -
{value_type.ValueType.STRING})
self._tp = TextParser({
'symbol':
concepts.SYMBOL_CONCEPT_INFO.name,
'symbol_reference':
syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name,
'type':
concepts.TYPE_CONCEPT_INFO.name,
'string_type':
types.STRING_TYPE_INFO.name,
'string_type_plain':
types.STRING_TYPE_INFO.name,
'list_type':
types.LIST_TYPE_INFO.name,
'path_type':
types.PATH_TYPE_INFO.name,
'A_ref_to_symbol_w_string_conversion':
types.a_ref_to_a_symbol_w_string_conversion__sentence(),
'non_str_types_w_str_rendering':
types.types__and_list(non_str_types_w_str_conversion),
'soft_quote':
syntax_descriptions.SOFT_QUOTE_NAME,
'hard_quote':
syntax_descriptions.HARD_QUOTE_NAME,
'SOFT_Q':
token.SOFT_QUOTE_CHAR,
'HARD_Q':
token.HARD_QUOTE_CHAR,
'CHR':
'CHARACTER',
'whitespace':
misc_texts.WHITESPACE,
'reserved_word':
misc_texts.RESERVED_WORD_NAME,
'reserved_word_list_str':
', '.join([
formatting.keyword(x) for x in reserved_words.RESERVED_TOKENS
]),
'Sym_refs_are_substituted':
syntax_descriptions.symbols_are_substituted_in(the_string_type),
'Sym_refs_are_not_substituted':
syntax_descriptions.symbols_are_not_substituted_in(
the_string_type),
'REL_CD_OPTION':
path.REL_CWD_OPTION,
})
def __init__(self, name: str,
instruction_set: Optional[SectionInstructionSet]):
"""
:param instruction_set: None if this phase does not have instructions.
"""
super().__init__(TestCasePhaseInfo(name))
self._instruction_set = instruction_set
self.__tp = TextParser({
'directive':
concepts.DIRECTIVE_CONCEPT_INFO.name,
'including':
formatting.keyword(
directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
def __init__(self, setup: Setup):
self._setup = setup
self._tp = TextParser({
'phase': setup.phase_names,
'program_name': formatting.program_name(program_info.PROGRAM_NAME),
'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name.singular,
'instructions': concepts.INSTRUCTION_CONCEPT_INFO.name.plural,
'ATC': concepts.ACTION_TO_CHECK_CONCEPT_INFO.singular_name,
'act_phase': phase_infos.ACT.name,
'symbol': concepts.SYMBOL_CONCEPT_INFO.name.singular,
'symbols': concepts.SYMBOL_CONCEPT_INFO.name.plural,
'cli_option_for_preprocessor': formatting.cli_option(OPTION_FOR_PREPROCESSOR),
'an_error_in_source': misc_texts.SYNTAX_ERROR_NAME.singular_determined,
'directive': concepts.DIRECTIVE_CONCEPT_INFO.name,
'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
def __init__(self):
self._tp = TextParser({
'phase':
phase_names.PHASE_NAME_DICTIONARY,
'program_name':
formatting.program_name(program_info.PROGRAM_NAME),
'instruction':
concepts.INSTRUCTION_CONCEPT_INFO.name,
'ATC':
concepts.ACTION_TO_CHECK_CONCEPT_INFO.singular_name,
'symbol':
concepts.SYMBOL_CONCEPT_INFO.name,
'directive':
concepts.DIRECTIVE_CONCEPT_INFO.name,
'actor':
concepts.ACTOR_CONCEPT_INFO.name,
'exit_code':
misc_texts.EXIT_CODE,
'exit_identifier':
misc_texts.EXIT_IDENTIFIER,
'act_phase':
phase_infos.ACT.name,
'cli_option_for_preprocessor':
formatting.cli_option(OPTION_FOR_PREPROCESSOR),
'an_error_in_source':
misc_texts.SYNTAX_ERROR_NAME.singular_determined,
'including':
formatting.keyword(
directives.INCLUDING_DIRECTIVE_INFO.singular_name),
'stdout':
misc_texts.STDOUT,
'execution':
processing.STEP_EXECUTION,
'validation':
processing.STEP_VALIDATION,
'preprocessing':
processing.STEP_PRE_PROCESSING,
})
def __init__(self, name: str):
super().__init__(name)
self._tp = TextParser({
'phase': phase_names.PHASE_NAME_DICTIONARY,
'setup': phase_infos.SETUP.name,
'action_to_check': concepts.ACTION_TO_CHECK_CONCEPT_INFO.name,
'home_directory': formatting.conf_param_(conf_params.HOME_CASE_DIRECTORY_CONF_PARAM_INFO),
'timeout_conf_param': formatting.conf_param_(conf_params.TIMEOUT_CONF_PARAM_INFO),
'sandbox': formatting.concept_(concepts.SANDBOX_CONCEPT_INFO),
'result_dir': tc_fs.SDS_RESULT_INFO.identifier,
'actor_option': OPTION_FOR_ACTOR,
'actor': concepts.ACTOR_CONCEPT_INFO.name,
'actor_instruction': formatting.InstructionName(ACTOR_INSTRUCTION_NAME),
'default_actor': actors.DEFAULT_ACTOR_SINGLE_LINE_VALUE,
'null_actor': formatting.entity_(actors.NULL_ACTOR),
'os_process': misc_texts.OS_PROCESS_NAME,
'act': phase_infos.ACT.name,
'stdin_instruction': InstructionName(instruction_names.CONTENTS_OF_STDIN_INSTRUCTION_NAME),
'conf_param': concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.name,
'directive': concepts.DIRECTIVE_CONCEPT_INFO.name,
'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
A relative path, using {posix_syntax}.
"""
_SPACE_SEPARATION_PARAGRAPH = 'All parts must be separated by {whitespace}.'
_TP = TextParser({
'FILE_MATCHER':
syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.singular_name,
'FILE_NAME':
syntax.FILE_NAME.name,
'FILE_CONDITION':
_FILE_CONDITION,
'STRING':
syntax_elements.STRING_SYNTAX_ELEMENT.singular_name,
'FILE_MATCHER_SEPARATOR':
formatting.keyword(syntax.FILE_MATCHER_SEPARATOR),
'posix_syntax':
documentation_text.POSIX_SYNTAX,
'CONJUNCTION':
logic.AND_OPERATOR_NAME,
'SPACE_SEPARATION_PARAGRAPH':
_SPACE_SEPARATION_PARAGRAPH.format(whitespace=misc_texts.WHITESPACE),
})
def _file_condition_sed() -> SyntaxElementDescription:
return SyntaxElementDescription(
_FILE_CONDITION, _TP.fnap(_FILE_CONDITION_DESCRIPTION_REST), [
invokation_variant_from_args([
syntax.FILE_NAME__ARG,
]),
"""
INTERMEDIATE_DIRS_ARE_CREATED = """\
Intermediate {dir_file_type:s} are created, if required.
"""
_SPACE_SEPARATION_PARAGRAPH = 'All parts must be separated by {whitespace}.'
_TP = TextParser({
'FILE_NAME':
syntax.FILE_NAME.name,
'FILE_SPEC':
syntax.FILE_SPEC__SE_STR,
'MODIFIERS':
english_text.and_sequence([
formatting.keyword(token)
for token in syntax.MODIFICATION_VARIANT_TOKENS.values()
]),
'parent_dir':
formatting.string_constant('..'),
'posix_syntax':
documentation_text.POSIX_SYNTAX,
'SPACE_SEPARATION_PARAGRAPH':
_SPACE_SEPARATION_PARAGRAPH.format(whitespace=misc_texts.WHITESPACE),
'dir_file_type':
file_types.DIRECTORY,
'regular_file_type':
file_types.REGULAR,
'regular_contents_type':
syntax_elements.STRING_SOURCE_SYNTAX_ELEMENT.singular_name,
'dir_contents_type':
phase_names.PHASE_NAME_DICTIONARY,
'instruction':
concepts.INSTRUCTION_CONCEPT_INFO.name,
'test_case_status':
formatting.conf_param(
conf_params.TEST_CASE_STATUS_CONF_PARAM_INFO.informative_name),
'default_status':
test_case_status.NAME_DEFAULT,
'error_in_source':
formatting.misc_name_with_formatting(misc_texts.SYNTAX_ERROR_NAME),
'exit_code':
formatting.misc_name_with_formatting(misc_texts.EXIT_CODE),
'exit_identifier':
formatting.misc_name_with_formatting(misc_texts.EXIT_IDENTIFIER),
'including':
formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
PREAMBLE = ''
REPORTING = """\
Outcome is reported either as {exit_code:a},
or as {exit_code:a} together with {exit_identifier:a} printed as a single
line on stdout.
"""
def _description_of_complete_execution() -> List[ParagraphItem]:
ret_val = []
ret_val.extend(
TEXT_PARSER.fnap(COMPLETE_EXECUTION_OUTCOME_DEPENDS_ON_TWO_THINGS))
def types__and_list(types: Sequence[ValueType]) -> str:
return english_text.and_sequence([
formatting.keyword(VALUE_TYPE_2_TYPES_INFO_DICT[t].singular_name)
for t in types
])
def text_until_end_of_line() -> InvokationVariant:
return invokation_variant_from_args([
a.Single(
a.Multiplicity.MANDATORY,
a.Constant(pgm_syntax_elements.
REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER)),
a.Single(a.Multiplicity.MANDATORY, TEXT_UNTIL_END_OF_LINE_ARGUMENT)
], _TEXT_PARSER.fnap(_TEXT_UNTIL_END_OF_LINE_DESCRIPTION))
_TEXT_PARSER = TextParser({
'Sym_refs_are_substituted':
syntax_descriptions.symbols_are_substituted_in(
TEXT_UNTIL_END_OF_LINE_ARGUMENT.name),
'White_pace':
misc_texts.WHITESPACE.capitalize(),
'token':
formatting.keyword(
pgm_syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER),
})
_TEXT_UNTIL_END_OF_LINE_DESCRIPTION = """\
The text after {token} until the end of the line becomes a single string.
{White_pace} at both ends is removed.
{Sym_refs_are_substituted}
"""
[all_exit_values_summary_table()]
)
),
]
)
TEXT_PARSER = TextParser({
'phase': phase_names.PHASE_NAME_DICTIONARY,
'test_case_status': formatting.conf_param(conf_params.TEST_CASE_STATUS_CONF_PARAM_INFO.informative_name),
'default_status': test_case_status.NAME_DEFAULT,
'an_error_in_source': misc_texts.SYNTAX_ERROR_NAME.singular_determined,
'an_exit_code': misc_texts.EXIT_CODE.singular_determined,
'an_exit_identifier': misc_texts.EXIT_IDENTIFIER.singular_determined,
'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name),
})
PREAMBLE = ''
REPORTING = """\
Outcome is reported either as {an_exit_code}, or as an exit code together with {an_exit_identifier} printed as a single
line on stdout.
"""
def _description_of_complete_execution(setup: Setup) -> List[ParagraphItem]:
ret_val = []
ret_val.extend(TEXT_PARSER.fnap(COMPLETE_EXECUTION_OUTCOME_DEPENDS_ON_TWO_THINGS))
ret_val.append(_what_outcome_depends_on(TEXT_PARSER))
ret_val.extend(TEXT_PARSER.fnap(TABLE_INTRO))
@property
def sub_syntax_element_definition_trees(self) -> List[SyntaxElementDescriptionTree]:
return [
rel_path_doc.path_element_3(PATH_OF_EXISTING_FILE_OPT_CONFIG,
_TEXT_PARSER.paras(the_path_of('an existing file.')))
]
PATH_OF_EXISTING_FILE_OPT_CONFIG = arg_config_with_name('PATH-OF-EXISTING-FILE',
pgm_syntax_elements.REL_OPTION_ARG_CONF)
EXECUTABLE_ARG = a.Named('EXECUTABLE')
_TEXT_PARSER = TextParser({
'program_name': formatting.program_name(program_info.PROGRAM_NAME),
'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular),
'string_se': formatting.syntax_element_(syntax_elements.STRING_SYNTAX_ELEMENT),
'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular),
'list_se': formatting.syntax_element_(syntax_elements.LIST_SYNTAX_ELEMENT),
'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular),
'path_se': formatting.syntax_element_(syntax_elements.PATH_SYNTAX_ELEMENT),
'program_type': formatting.keyword(types.PROGRAM_TYPE_INFO.name.singular),
'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO),
'hds': formatting.concept_(concepts.HOME_DIRECTORY_STRUCTURE_CONCEPT_INFO),
'SYMBOL_REFERENCE_SYNTAX_ELEMENT': formatting.syntax_element_(syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT),
'TRANSFORMATION': instruction_arguments.STRING_TRANSFORMATION_ARGUMENT.name,
'define_symbol': instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME,
'TEXT_UNTIL_END_OF_LINE': instruction_arguments.TEXT_UNTIL_END_OF_LINE_ARGUMENT.name,
'SYMBOL_NAME': formatting.syntax_element_(syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT),
'THE_PYTHON_INTERPRETER': program_info.PYTHON_INTERPRETER_WHICH_CAN_RUN_THIS_PROGRAM,
'PATH_OF_EXISTING_FILE': PATH_OF_EXISTING_FILE_OPT_CONFIG.argument_syntax_name,
def description_rest(self) -> Sequence[ParagraphItem]:
tp = TextParser({
'aliased': formatting.keyword(self._name),
})
return tp.fnap(_DESCRIPTION)
