def custom_separation(self):
custom_separations = lists.Separations(10, 20)
formatter = sut.Formatter(CROSS_REF_TITLE_ONLY_TEXT_FORMATTER,
sut.Wrapper(page_width=100),
list_formats=self.LIST_FORMATS)
actual = formatter.resolve_list_format(
lists.Format(lists.ListType.VARIABLE_LIST,
custom_separations=custom_separations))
self.assertIs(custom_separations, actual.separations)
def test_only_initial_paragraphs(self):
paragraph_item_formatter = paragraph_item.Formatter(
CROSS_REF_TITLE_ONLY_TEXT_FORMATTER,
paragraph_item.Wrapper(page_width=5),
num_item_separator_lines=1,
list_formats=lf.ListFormats(variable_list_format=lf.ListFormat(
lf.HeaderAndIndentFormatPlain(),
lists.Separations(0, 0),
indent_str='')))
formatter = sut.Formatter(paragraph_item_formatter)
section_contents = SectionContents([
single_text_para('12345 123 5'),
lists.HeaderContentList(
[header_only_item('12345 123')],
lists.Format(lists.ListType.VARIABLE_LIST),
)
], [])
actual = formatter.format_section_contents(section_contents)
self.assertEqual(['12345', '123 5', BLANK_LINE, '12345', '123'],
actual)
from typing import Iterable, List, Sequence, Optional
from exactly_lib.common.help.headers import WHERE_PARA, FORMS_PARA
from exactly_lib.common.help.syntax_contents_structure import InvokationVariant, SyntaxElementDescription
from exactly_lib.definitions.doc_format import syntax_text
from exactly_lib.help import std_tags
from exactly_lib.util.textformat.structure import document as doc, lists
from exactly_lib.util.textformat.structure import structures as docs
from exactly_lib.util.textformat.structure.core import ParagraphItem
_SYNTAX_LINE_TAGS = frozenset([std_tags.SYNTAX_TEXT])
LIST_INDENT = 2
BLANK_LINE_BETWEEN_ELEMENTS = lists.Separations(1, 1)
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),
BLANK_LINE, CROSS_REF_TITLE_ONLY_TEXT_FORMATTER
def suite() -> unittest.TestSuite:
ret_val = unittest.TestSuite()
ret_val.addTest(unittest.makeSuite(TestHeaderOnlyListItemsWithNoLineWraps))
ret_val.addTest(unittest.makeSuite(TestHeaderOnlyListItemsWithLineWraps))
ret_val.addTest(unittest.makeSuite(TestContentFormatting))
ret_val.addTest(unittest.makeSuite(TestThatIdentationIsNotModified))
ret_val.addTest(unittest.makeSuite(TestResolveListFormat))
ret_val.addTest(unittest.makeSuite(TestWholeListIndent))
return ret_val
NO_SEPARATIONS = lists.Separations(
num_blank_lines_between_elements=0,
num_blank_lines_between_header_and_contents=0)
list_formatter_with_no_blank_lines = lf.ListFormat(
lf.HeaderAndIndentFormatWithNumbering(contents_indent_spaces=3),
NO_SEPARATIONS,
indent_str='')
class TestHeaderOnlyListItemsWithNoLineWraps(unittest.TestCase):
def test_empty_list(self):
items = []
formatter = formatter_with_page_width(10)
actual = formatter.format_header_value_list_according_to_format(
items, list_formatter_with_no_blank_lines)
self.assertEqual([], actual)
from typing import List, Union, Optional, Iterable, TypeVar, Sequence
from exactly_lib.util.textformat.structure import document
from exactly_lib.util.textformat.structure import lists
from exactly_lib.util.textformat.structure import table
from exactly_lib.util.textformat.structure.core import ParagraphItem, ConcreteText, StringText, CrossReferenceTarget, \
CrossReferenceText, Text, AnchorText
from exactly_lib.util.textformat.structure.document import Section, SectionContents, SectionItem
from exactly_lib.util.textformat.structure.literal_layout import LiteralLayout
from exactly_lib.util.textformat.structure.paragraph import Paragraph
from exactly_lib.util.textformat.structure.table import TableCell, Table, TableFormat
SEPARATION_OF_HEADER_AND_CONTENTS = lists.Separations(1, 1)
COLON_TABLE_COLUMN_SEPARATOR = ' : '
StrOrText = Union[str, Text]
StrOrStringText = Union[str, StringText]
T = TypeVar('T')
def section(header_str_or_text: StrOrText,
paragraphs: List[ParagraphItem],
sub_sections: List[SectionItem] = None) -> Section:
return Section(
text_from_unknown(header_str_or_text),
SectionContents(paragraphs, _empty_list_if_none(sub_sections)))
class ListSettings(tuple):
def __new__(cls, custom_indent_spaces: int,
custom_separations: lists.Separations):
return tuple.__new__(cls, (custom_indent_spaces, custom_separations))
@property
def custom_indent_spaces(self) -> int:
return self[0]
@property
def custom_separations(self) -> lists.Separations:
return self[1]
DEFAULT_LIST_SETTINGS = ListSettings(None, lists.Separations(1, 1))
def parse(
normalized_lines: List[str],
list_settings: ListSettings = DEFAULT_LIST_SETTINGS
) -> List[ParagraphItem]:
return _Parser(normalized_lines, list_settings).apply()
def normalize_lines(text: str) -> List[str]:
ret_val = textwrap.dedent(text).splitlines()
_strip_empty_lines(ret_val)
return ret_val