def _relativity_options_paragraph(self) -> ParagraphItem:
return docs.simple_list_with_space_between_elements_and_content([
docs.list_item(
self._options_for_directories_in_the(concepts.HOME_DIRECTORY_STRUCTURE_CONCEPT_INFO),
self._options_for_directories_in_the_hds(),
),
docs.list_item(
self._options_for_directories_in_the(concepts.SANDBOX_CONCEPT_INFO),
self._options_for_directories_in_the_sds(),
),
docs.list_item(
self._parser.format('Option for {cd}'),
self._options_for_current_directory(),
),
docs.list_item(
self._parser.format('Option for a path denoted by a {symbol}'),
self._options_for_symbol(),
),
docs.list_item(
self._parser.format('Option for the location of the current source file'),
self._options_for_rel_source_file(),
),
],
docs.lists.ListType.ITEMIZED_LIST,
)
def processing_step_list(self) -> docs.ParagraphItem:
items = [
docs.list_item('Preprocessing',
step_with_single_exit_value(
self._tp.fnap(PURPOSE_OF_PREPROCESSING),
self._tp.para(FAILURE_CONDITION_OF_PREPROCESSING),
exit_values.NO_EXECUTION__PRE_PROCESS_ERROR)
),
docs.list_item(self._tp.text('Syntax checking and {directive:s} processing'),
step_with_multiple_exit_values(
self._tp.fnap(PURPOSE_OF_SYNTAX_CHECKING),
self._tp.fnap(FAILURE_CONDITION_OF_SYNTAX_CHECKING),
[
('Syntax error', exit_values.NO_EXECUTION__SYNTAX_ERROR),
('File inclusion error', exit_values.NO_EXECUTION__FILE_ACCESS_ERROR),
])
),
docs.list_item('Validation',
step_with_single_exit_value(
self._tp.fnap(PURPOSE_OF_VALIDATION),
self._tp.para(FAILURE_CONDITION_OF_VALIDATION),
exit_values.EXECUTION__VALIDATION_ERROR)
),
docs.list_item('Execution',
self._tp.fnap(EXECUTION_DESCRIPTION) +
[self.execution_sub_steps_description()] +
self._tp.fnap(OUTCOME_OF_EXECUTION)),
]
return lists.HeaderContentList(items,
lists.Format(lists.ListType.ORDERED_LIST,
custom_separations=docs.SEPARATION_OF_HEADER_AND_CONTENTS)
)
def _relativity_options_paragraph(self) -> ParagraphItem:
return docs.simple_list_with_space_between_elements_and_content([
docs.list_item(
self._options_for_directories_in_the(concepts.HDS_CONCEPT_INFO),
self._options_for_directories_in_the_hds(),
),
docs.list_item(
self._options_for_directories_in_the(concepts.SDS_CONCEPT_INFO),
self._options_for_directories_in_the_sds(),
),
docs.list_item(
self._parser.format('Option for {cd}'),
self._options_for_current_directory(),
),
docs.list_item(
self._parser.format('Option for a path denoted by a {symbol}'),
self._options_for_symbol(),
),
docs.list_item(
self._parser.format('Option for the location of the current source file'),
self._options_for_rel_source_file(),
),
],
docs.lists.ListType.ITEMIZED_LIST,
)
def _categories_list(data_types_header: str, logic_types_header: str) -> ParagraphItem:
items = [
docs.list_item(data_types_header,
[_list_types_in_category(TypeCategory.DATA)]),
docs.list_item(logic_types_header,
[_list_types_in_category(TypeCategory.LOGIC)]),
]
return docs.simple_list_with_space_between_elements_and_content(items, ListType.ITEMIZED_LIST)
def execution_sub_steps_description(self) -> docs.ParagraphItem:
return lists.HeaderContentList([
docs.list_item(self._tp.text('execution of {phase[setup]:syntax}')),
docs.list_item(docs.text(post_setup_validation_step_name(self._setup))),
docs.list_item(docs.text('execution of remaining phases')),
],
lists.Format(lists.ListType.ORDERED_LIST,
custom_separations=docs.SEPARATION_OF_HEADER_AND_CONTENTS)
)
def _custom_environment_info_items(self) -> Sequence[docs.lists.HeaderContentListItem]:
return [
docs.list_item(
'stdin',
self._tp.fnap(_STDIN)
),
docs.list_item(
conf_params.TIMEOUT_CONF_PARAM_INFO.singular_name.capitalize(),
self._tp.fnap(_TIMEOUT)
),
]
def files(self) -> Optional[docs.SectionContents]:
list_items = [
docs.list_item(_TP.text(_FILES_WHEN_REPORTING_FOR_A_CASE_HEADER),
_TP.fnap(FILES_DESCRIPTION_WITH_DEFAULT_SUITE)),
docs.list_item(_TP.text(_FILES_WHEN_REPORTING_FOR_A_SUITE_HEADER),
_TP.fnap(DEFAULT_SUITE_FILES_DESCRIPTION)),
]
return docs.section_contents([
docs.simple_list_with_space_between_elements_and_content(
list_items, docs.lists.ListType.ITEMIZED_LIST)
])
def _synopsis_list_items(
self, synopsis: Synopsis) -> List[lists.HeaderContentListItem]:
headers = list(
map(self.cmd_line_syntax_renderer.apply, synopsis.command_lines))
content_paragraph_items = []
if synopsis.maybe_single_line_description:
content_paragraph_items.append(
docs.para(synopsis.maybe_single_line_description))
content_paragraph_items += synopsis.paragraphs
return ([docs.list_item(header) for header in headers[:-1]] +
[docs.list_item(headers[-1], content_paragraph_items)])
def _custom_environment_info_items(self) -> Sequence[docs.lists.HeaderContentListItem]:
return [
docs.list_item(
misc_texts.STDIN.capitalize(),
self._tp.fnap(_STDIN)
),
]
def _dir_item(self, x: _DirInfo) -> HeaderContentListItem:
def prop_row(header: str, value_str_or_text) -> List[docs.TableCell]:
return [docs.text_cell(header),
docs.text_cell(value_str_or_text),
]
from exactly_lib.test_case_file_structure.relative_path_options import REL_HOME_OPTIONS_MAP
properties_table = docs.first_column_is_header_table(
[
prop_row('Default value',
x.default_value_description),
prop_row(concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.singular_name.capitalize(),
x.conf_param.configuration_parameter_name_text),
prop_row('Set by instruction',
instruction_name_text(x.instruction_name)),
prop_row('Variable name',
REL_HOME_OPTIONS_MAP[x.relativity_option_type].directory_variable_name_text),
prop_row('Relativity option',
REL_HOME_OPTIONS_MAP[x.relativity_option_type].option_name_text),
]
)
paras = [
docs.para(x.conf_param.single_line_description_str),
properties_table,
]
return docs.list_item(self._tp.text(x.item_name), paras)
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 _dir_item(self, x: _DirInfo) -> HeaderContentListItem:
def prop_row(header: str, value_str_or_text) -> List[docs.TableCell]:
return [
docs.text_cell(header),
docs.text_cell(value_str_or_text),
]
from exactly_lib.tcfs.relative_path_options import REL_HDS_OPTIONS_MAP
properties_table = docs.first_column_is_header_table([
prop_row('Default value', x.default_value_description),
prop_row(
concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.singular_name.
capitalize(), x.conf_param.configuration_parameter_name_text),
prop_row('Set by instruction',
instruction_name_text(x.instruction_name)),
prop_row(
BUILTIN_SYMBOL_ENTITY_TYPE_NAMES.name.singular.capitalize(),
REL_HDS_OPTIONS_MAP[
x.relativity_option_type].directory_symbol_name_text),
prop_row(
'Path relativity option', REL_HDS_OPTIONS_MAP[
x.relativity_option_type].option_name_text),
])
paras = [
docs.para(x.conf_param.single_line_description_str),
properties_table,
]
return docs.list_item(self._tp.text(x.item_name), paras)
def instruction_set_list_item(
description: InstructionDocumentation,
name_2_name_text_fun: Callable[[str], docs.Text]
) -> lists.HeaderContentListItem:
description_para = docs.para(description.single_line_description())
return docs.list_item(name_2_name_text_fun(description.instruction_name()),
[description_para])
def syntax_element_description_list() -> ParagraphItem:
items = []
for sed in syntax_element_descriptions:
variants_list_paragraphs = []
if sed.invokation_variants:
variants_list_paragraphs = [variants_list(None,
sed.invokation_variants,
True,
custom_separations=BLANK_LINE_BETWEEN_ELEMENTS)]
separator_paras = (
[FORMS_PARA]
if sed.invokation_variants and invokation_variants_are_surrounded_by_text(sed)
else []
)
contents = (
list(sed.before_invokation_variants) +
separator_paras +
variants_list_paragraphs +
list(sed.after_invokation_variants)
)
items.append(docs.list_item(syntax_text(sed.element_name),
contents))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=_custom_list_indent(True),
custom_separations=BLANK_LINE_BETWEEN_ELEMENTS))
def execution_modes_list() -> ParagraphItem:
items = [
docs.list_item(doc_format.enum_name_text(x[0]), x[1])
for x in _mode_name_and_paragraphs_list()
]
return docs.simple_list_with_space_between_elements_and_content(
items, lists.ListType.VARIABLE_LIST)
def _synopsis_list_item(self, synopsis: Synopsis) -> lists.HeaderContentListItem:
header = self.cmd_line_syntax_renderer.apply(synopsis.command_line)
content_paragraph_items = []
if synopsis.maybe_single_line_description:
content_paragraph_items.append(docs.para(synopsis.maybe_single_line_description))
content_paragraph_items += synopsis.paragraphs
return docs.list_item(header, content_paragraph_items)
def processing_step_list(self) -> docs.ParagraphItem:
items = [
docs.list_item(
processing.STEP_PRE_PROCESSING.singular.capitalize(),
step_with_single_exit_value(
self._tp.fnap(PURPOSE_OF_PREPROCESSING),
self._tp.para(FAILURE_CONDITION_OF_PREPROCESSING),
exit_values.NO_EXECUTION__PRE_PROCESS_ERROR)),
docs.list_item(
self._tp.text('Syntax checking and {directive:s} processing'),
step_with_multiple_exit_values(
self._tp.fnap(PURPOSE_OF_SYNTAX_CHECKING),
self._tp.fnap(FAILURE_CONDITION_OF_SYNTAX_CHECKING),
[
NameAndValue('Syntax error',
exit_values.NO_EXECUTION__SYNTAX_ERROR),
NameAndValue(
'File inclusion error',
exit_values.NO_EXECUTION__FILE_ACCESS_ERROR),
],
)),
docs.list_item(
self._tp.text(
'{validation:/u} and syntax checking of {act_phase:syntax}'
),
step_with_multiple_exit_values(
self._tp.fnap(PURPOSE_OF_VALIDATION),
self._tp.fnap(FAILURE_CONDITION_OF_VALIDATION),
[
NameAndValue(
self._tp.text(
'Invalid syntax of {act_phase:syntax}'),
exit_values.EXECUTION__SYNTAX_ERROR),
NameAndValue(
self._tp.text(
'Invalid reference to {symbol} or external resource'
), exit_values.EXECUTION__VALIDATION_ERROR),
],
)),
docs.list_item(processing.STEP_EXECUTION.singular.capitalize(),
self._tp.fnap(EXECUTION_DESCRIPTION)),
]
return lists.HeaderContentList(
items,
lists.Format(
lists.ListType.ORDERED_LIST,
custom_separations=docs.SEPARATION_OF_HEADER_AND_CONTENTS))
def parse_list_item_from_item_line(self,
first_item_header_line: str,
item_line_prefix: str) -> lists.HeaderContentListItem:
item_line_prefix_len = len(item_line_prefix)
header = first_item_header_line[item_line_prefix_len:].strip()
content_paragraph_items = self.parse_list_content_paragraph_items(item_line_prefix_len)
return docs.list_item(StringText(header), content_paragraph_items)
def _item(
self,
arguments: Sequence[a.ArgumentUsage],
description_template: str,
) -> lists.HeaderContentListItem:
return docs.list_item(
doc_format.syntax_text(cl_syntax.cl_syntax_for_args(arguments)),
self._tp.fnap(description_template))
def _directory_structure_list(dir_with_sub_dir_list: List[DirWithSubDirs]) -> ParagraphItem:
items = []
for dir_wsd in dir_with_sub_dir_list:
sub_dirs_items = []
if dir_wsd.sub_dirs:
sub_dirs_items = [_directory_structure_list(dir_wsd.sub_dirs)]
items.append(docs.list_item(dir_name_text(dir_wsd.name), sub_dirs_items))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.ITEMIZED_LIST))
def parse_list_item_from_item_line(
self, first_item_header_line: str,
item_line_prefix: str) -> lists.HeaderContentListItem:
item_line_prefix_len = len(item_line_prefix)
header = first_item_header_line[item_line_prefix_len:].strip()
content_paragraph_items = self.parse_list_content_paragraph_items(
item_line_prefix_len)
return docs.list_item(StringText(header), content_paragraph_items)
def _types_categories_list(tp: TextParser) -> ParagraphItem:
return docs.simple_list_with_space_between_elements_and_content(
[
docs.list_item(type_system.TYPE_CATEGORY_NAME[category],
tp.fnap(_TYPE_CATEGORY_DESCRIPTION[category]))
for category in type_system.TypeCategory
],
ListType.ITEMIZED_LIST,
)
def _current_directory_items(self) -> List[lists.HeaderContentListItem]:
eei = self.doc.execution_environment_info()
if eei.cwd_at_start_of_phase:
list_item = docs.list_item(
'{cd:/u}'.format(
cd=concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO.name),
eei.cwd_at_start_of_phase)
return [list_item]
else:
return []
def _current_directory_items(self) -> List[lists.HeaderContentListItem]:
eei = self.doc.execution_environment_info()
if eei.cwd_at_start_of_phase:
list_item = docs.list_item(
'{cd:/u}'.format(cd=concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO.name),
eei.cwd_at_start_of_phase
)
return [list_item]
else:
return []
def _dir_structure_item(self,
dir_structure: SingularAndPluralNameAndCrossReferenceId,
tc_dir_infos: List[TcDirInfo],
) -> lists.HeaderContentListItem:
contents = [
docs.para(dir_structure.single_line_description),
self._dirs_list(tc_dir_infos)
]
return docs.list_item(dir_structure.singular_name.capitalize(),
contents)
def _grouped_instructions(self, environment: ConstructionEnvironment) -> ParagraphItem:
items = []
for group in self.instruction_group_by(self.instruction_set.instruction_documentations):
items.append(docs.list_item(group.header,
[
self.instruction_set_list(group.instruction_documentations,
environment)])
)
return docs.simple_list_with_space_between_elements_and_content(items,
ListType.ITEMIZED_LIST)
def _directory_structure_list(
dir_with_sub_dir_list: List[DirWithSubDirs]) -> ParagraphItem:
items = []
for dir_wsd in dir_with_sub_dir_list:
sub_dirs_items = []
if dir_wsd.sub_dirs:
sub_dirs_items = [_directory_structure_list(dir_wsd.sub_dirs)]
items.append(
docs.list_item(dir_name_text(dir_wsd.name), sub_dirs_items))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.ITEMIZED_LIST))
def _timeout_items(self) -> List[lists.HeaderContentListItem]:
eei = self.doc.execution_environment_info()
paragraphs = []
paragraphs += eei.timeout_prologue
if paragraphs:
list_item = docs.list_item(
'{timeout:/u}'.format(
timeout=concepts.TIMEOUT_CONCEPT_INFO.name), paragraphs)
return [list_item]
else:
return []
def toc_list(target_info_hierarchy: Sequence[TargetInfoNode],
list_type: lists.ListType) -> doc.ParagraphItem:
items = []
for node in target_info_hierarchy:
sub_lists = []
if node.children:
sub_lists = [toc_list(node.children, list_type)]
item = docs.list_item(
docs.cross_reference(node.data.presentation_text,
node.data.target), sub_lists)
items.append(item)
return lists.HeaderContentList(items, lists.Format(list_type))
def _sorted_conf_params_list() -> ParagraphItem:
all_cfs = sorted(ALL_CONF_PARAM_INFOS,
key=SingularNameAndCrossReferenceId.singular_name.fget)
items = [docs.list_item(docs.cross_reference(cf.configuration_parameter_name_text,
cf.cross_reference_target,
allow_rendering_of_visible_extra_target_text=False),
docs.paras(cf.single_line_description_str))
for cf in all_cfs]
return lists.HeaderContentList(items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=0,
custom_separations=docs.SEPARATION_OF_HEADER_AND_CONTENTS))
def _sorted_entities_list(
self, entities: Iterable[EntityDocumentation]
) -> lists.HeaderContentList:
items = [
docs.list_item(entity.singular_name(),
self.entity_2_summary_paragraphs(entity))
for entity in (sorted_entity_list(entities))
]
return lists.HeaderContentList(
items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=0,
custom_separations=SEPARATION_OF_HEADER_AND_CONTENTS))
def _environment_variables_items(
self) -> List[lists.HeaderContentListItem]:
eei = self.doc.execution_environment_info()
paragraphs = []
paragraphs += eei.environment_variables_prologue
if paragraphs:
list_item = docs.list_item(
'{ev:s/u}'.format(
ev=concepts.ENVIRONMENT_VARIABLE_CONCEPT_INFO.name),
paragraphs)
return [list_item]
else:
return []
def variants_list(instruction_name: Optional[str],
invokation_variants: Iterable[InvokationVariant],
indented: bool = False,
custom_separations: lists.Separations = None) -> ParagraphItem:
title_prefix = instruction_name + ' ' if instruction_name else ''
items = []
for x in invokation_variants:
assert isinstance(x, InvokationVariant)
title = title_prefix + x.syntax
items.append(docs.list_item(syntax_text(title),
list(x.description_rest)))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=_custom_list_indent(indented),
custom_separations=custom_separations))
def variants_list(instruction_name: str,
invokation_variants: Iterable[InvokationVariant],
indented: bool = False,
custom_separations: lists.Separations = None) -> ParagraphItem:
title_prefix = instruction_name + ' ' if instruction_name else ''
items = []
for x in invokation_variants:
assert isinstance(x, InvokationVariant)
title = title_prefix + x.syntax
items.append(docs.list_item(syntax_text(title),
list(x.description_rest)))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=_custom_list_indent(indented),
custom_separations=custom_separations))
def _sorted_conf_params_list() -> ParagraphItem:
all_cfs = sorted(ALL_CONF_PARAM_INFOS,
key=SingularNameAndCrossReferenceId.singular_name.fget)
items = [
docs.list_item(
docs.cross_reference(
cf.configuration_parameter_name_text,
cf.cross_reference_target,
allow_rendering_of_visible_extra_target_text=False),
docs.paras(cf.single_line_description_str)) for cf in all_cfs
]
return lists.HeaderContentList(
items,
lists.Format(
lists.ListType.VARIABLE_LIST,
custom_indent_spaces=0,
custom_separations=docs.SEPARATION_OF_HEADER_AND_CONTENTS))
def syntax_element_description_list() -> ParagraphItem:
items = []
for x in syntax_element_descriptions:
assert isinstance(x, SyntaxElementDescription)
variants_list_paragraphs = []
if x.invokation_variants:
variants_list_paragraphs = [variants_list(None,
x.invokation_variants,
True,
custom_separations=BLANK_LINE_BETWEEN_ELEMENTS)]
separator_paras = [FORMS_PARA] if x.invokation_variants and x.description_rest else []
contents = list(x.description_rest) + separator_paras + variants_list_paragraphs
items.append(docs.list_item(syntax_text(x.element_name),
contents))
return lists.HeaderContentList(items,
lists.Format(lists.ListType.VARIABLE_LIST,
custom_indent_spaces=_custom_list_indent(True),
custom_separations=BLANK_LINE_BETWEEN_ELEMENTS))
def _environment_variables_items(self) -> List[lists.HeaderContentListItem]:
eei = self.doc.execution_environment_info()
paragraphs = []
paragraphs += eei.environment_variables_prologue
if eei.environment_variables:
paragraphs.extend([docs.para('The following environment variables are set:'),
self._environment_variables_list(eei.environment_variables)])
if self.doc.name.plain == ACT_PHASE_NAME:
# FIXME Remove setting of env vars for the act phase.
paragraphs.append(docs.para('NOTE: In future versions, '
'these environment variables will not be available!'))
if paragraphs:
list_item = docs.list_item(
'{ev:s/u}'.format(ev=concepts.ENVIRONMENT_VARIABLE_CONCEPT_INFO.name),
paragraphs
)
return [list_item]
else:
return []
def item_for(syntax: str, description: str) -> lists.HeaderContentListItem:
return docs.list_item(syntax_text(syntax), docs.paras(description))
def item(purpose: AssertPhasePurpose) -> lists.HeaderContentListItem:
info = _INSTRUCTION_TYPES[purpose]
return docs.list_item(info[0],
self._tp.fnap(info[2]))
def list_item(doc: SectionDocumentation) -> HeaderContentListItem:
paras = [docs.para(doc.purpose().single_line_description)]
add_default_info(doc, paras)
return docs.list_item(doc.syntax_name_cross_ref_text, paras)
def execution_modes_list() -> ParagraphItem:
items = [docs.list_item(doc_format.enum_name_text(x[0]), x[1])
for x in _mode_name_and_paragraphs_list()]
return docs.simple_list_with_space_between_elements_and_content(items,
lists.ListType.VARIABLE_LIST)
def failure_item(header__exit_value: NameAndValue[ExitValue]) -> docs.lists.HeaderContentListItem:
return docs.list_item(header__exit_value.name,
[singe_exit_value_display(header__exit_value.value)])
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 failure_item(header__exit_value: Tuple[str, ExitValue]) -> docs.lists.HeaderContentListItem:
return docs.list_item(header__exit_value[0],
[singe_exit_value_display(header__exit_value[1])])
def _arg_description_list_item(self, argument: DescribedArgument) -> lists.HeaderContentListItem:
header = doc_format.syntax_text(self.arg_in_description_renderer.visit(argument.argument))
return docs.list_item(header, self._arg_description_list_item_contents(argument))
Pattern matchers:
"""
_DIRECTORY_SPECIFICATIONS_HEADER = 'Directory specifications:'
_FOOTER = """\
For a literal match, wrap the meta-characters in brackets. For example, '[?]' matches the character '?'.
A patterns cannot denote an absolute path.
"""
_PATTERNS = docs.simple_list_with_space_between_elements_and_content([
docs.list_item(syntax_text('?'),
docs.paras('Matches any single character.')
),
docs.list_item(syntax_text('*'),
docs.paras('Matches any number of any characters including none.')
),
docs.list_item(syntax_text('[CHARACTERS]'),
docs.paras('Matches a single character that is listed in CHARACTERS. ')
),
docs.list_item(syntax_text('[CHARACTER-CHARACTER]'),
docs.paras('Matches a single character in the given range.')
),
docs.list_item(syntax_text('[!CHARACTER-SET]'),
docs.paras('Matches a single character NOT in CHARACTER-SET.')
),
],
lists.ListType.ITEMIZED_LIST)
def _arg_description_list_item(
self, argument: DescribedArgument) -> lists.HeaderContentListItem:
header = doc_format.syntax_text(
self.arg_in_description_renderer.visit(argument.argument))
return docs.list_item(
header, self._arg_description_list_item_contents(argument))
_HEADER = """\
Unix shell-style wildcards.
Patterns:
"""
_DIRECTORY_SPECIFICATIONS_HEADER = 'Directory specifications:'
_FOOTER = """\
For a literal match, wrap the meta-characters in brackets. For example, '[?]' matches the character '?'.
"""
_PATTERNS = docs.simple_list_with_space_between_elements_and_content([
docs.list_item(syntax_text('?'),
docs.paras('Matches any single character.')
),
docs.list_item(syntax_text('*'),
docs.paras('Matches any number of any characters including none.')
),
docs.list_item(syntax_text('[CHARACTERS]'),
docs.paras('Matches a single character that is listed in CHARACTERS.')
),
docs.list_item(syntax_text('[CHARACTER-CHARACTER]'),
docs.paras('Matches a single character in the given range.')
),
docs.list_item(syntax_text('[!CHARACTERS]'),
docs.paras('Matches a single character that is not listed in CHARACTERS.')
),
],
lists.ListType.ITEMIZED_LIST)
def _types_category_list_item(category: TypeCategory) -> HeaderContentListItem:
return docs.list_item(type_system.TYPE_CATEGORY_NAME[category],
[_list_types_in_category(category)])
def _item(self, var_name: str) -> lists.HeaderContentListItem:
return docs.list_item(directory_variable_name_text(var_name),
environment_variables.ENVIRONMENT_VARIABLE_DESCRIPTION.as_description_paragraphs(
var_name))
def item(purpose: AssertPhasePurpose) -> lists.HeaderContentListItem:
info = _INSTRUCTION_TYPES[purpose]
return docs.list_item(info[0],
self._tp.fnap(info[2]))
def item_for(syntax: str, description: str) -> lists.HeaderContentListItem:
return docs.list_item(syntax_text(syntax),
docs.paras(description))
def instruction_set_list_item(description: InstructionDocumentation,
name_2_name_text_fun: Callable[[str], docs.Text]) -> lists.HeaderContentListItem:
description_para = docs.para(description.single_line_description())
return docs.list_item(name_2_name_text_fun(description.instruction_name()),
[description_para])
