def set_numbering(self):
"""
Sets the numbering status to the heading node.
"""
if 'numbering' in self._options:
if self._options['numbering'] == 'off':
self.numbering = False
elif self._options['numbering'] == 'on':
self.numbering = True
else:
NodeStore.error("Invalid value '{}' for attribute 'numbering'. Allowed values are 'on' and 'off'.".
format(self._options['numbering']), self)
def set_numbering(self) -> None:
"""
Sets the numbering status to the heading node.
"""
if 'numbering' in self._options:
if self._options['numbering'] == 'off':
self.numbering = False
elif self._options['numbering'] == 'on':
self.numbering = True
else:
NodeStore.error(
"Invalid value '{}' for attribute 'numbering'. Allowed values are 'on' and 'off'."
.format(self._options['numbering']), self)
def __check_document_info(info_node_current, info_node_new):
"""
Checks if a document info node has been set already. If so, an error will be logged.
:param int|None info_node_current: The current document info node (i.e. a property of the document).
:param sdoc.sdoc2.node.Node.Node info_node_new: The (new) document info node.
"""
if info_node_current:
node = in_scope(info_node_current)
position = node.position
out_scope(node)
NodeStore.error("Document info {0} can be specified only once. Previous definition at {1}.".format(
info_node_new.name, str(position)), info_node_new)
def generate(self, node, file):
"""
Generates the HTML code for an icon node.
:param sdoc.sdoc2.node.IconNode.IconNode node: The icon node.
:param file file: The output file.
"""
attributes = IconNode.get_definition(node.argument)
if attributes:
img_element = Html.generate_void_element('img', attributes)
file.write(img_element)
else:
NodeStore.error("There is no definition for icon with name '{}'".format(node.argument), node)
def generate(self, node: IconNode, file: Any) -> None:
"""
Generates the HTML code for an icon node.
:param IconNode node: The icon node.
:param any file: The output file.
"""
attributes = IconNode.get_definition(node.argument)
if attributes:
img_element = Html.generate_void_element('img', attributes)
file.write(img_element)
else:
NodeStore.error(
"There is no definition for icon with name '{}'".format(
node.argument), node)
def __check_document_info(info_node_current: Optional[int],
info_node_new: Node) -> None:
"""
Checks if a document info node has been set already. If so, an error will be logged.
:param int|None info_node_current: The current document info node (i.e. a property of the document).
:param Node info_node_new: The (new) document info node.
"""
if info_node_current:
node = in_scope(info_node_current)
position = node.position
out_scope(node)
NodeStore.error(
"Document info {0} can be specified only once. Previous definition at {1}."
.format(info_node_new.name, str(position)), info_node_new)
def __init__(self):
"""
Object constructor.
"""
# Create node store.
sdoc.sdoc2.node_store = NodeStore()
# Import all node modules.
self.importing('/node/')
self.importing('/decorator/html/')
def _generate_table_cell(align: Optional[str], cell: Any) -> str:
"""
Returns the 'column' with HTML data.
:param str|None align:
:param any cell: The column in a table.
"""
attributes = {}
if align:
attributes['style'] = "text-align: {0}".format(align)
if isinstance(cell, str):
data = cell
is_html = False
else:
# Generates html in nested node ('cell') with specified formatter.
formatter = NodeStore.get_formatter('html', cell.get_command())
data = formatter.get_html(cell)
is_html = True
return Html.generate_element('td', attributes, data, is_html)
def _generate_table_cell(align, col):
"""
Returns the 'column' with HTML data.
:param mixed col: The column in a table.
:rtype: str
"""
attributes = {}
if align:
attributes['style'] = "text-align: {0}".format(align)
if isinstance(col, str):
data = col
is_html = False
else:
# Generates html in nested node ('col') with specified formatter.
formatter = NodeStore.get_formatter('html', col.get_command())
data = formatter.get_html(col)
is_html = True
return Html.generate_element('td', attributes, data, is_html)
sdoc.sdoc2.node_store.store_node(text_node)
text_ids.append(text_node.id)
end_paragraph_node = sdoc.sdoc2.node_store.create_inline_node('end_paragraph')
text_ids.append(end_paragraph_node.id)
# Checking where we need to add paragraph.
if text_ids:
if list_of_texts[-1]:
text_ids.pop()
return text_ids
# ------------------------------------------------------------------------------------------------------------------
def prune_whitespace(self, leading: bool = False, trailing: bool = False):
"""
Method for removing whitespace in text.
:param bool leading: if True, remove whitespaces from start.
:param bool trailing: if True, remove whitespaces from end.
"""
if leading:
self._argument = self._argument.lstrip()
if trailing:
self._argument = self._argument.rstrip()
self._argument = re.sub(r'\s+', ' ', self._argument)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('TEXT', TextNode)
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def generate_toc(self) -> None:
"""
Generates the table of contents.
"""
self._options['ids'] = []
for node in node_store.nodes.values():
if not isinstance(node, ParagraphNode) and isinstance(node, HeadingNode):
node.set_toc_id()
data = {'id': node.get_option_value('id'),
'arg': node.argument,
'level': node.get_hierarchy_level(),
'number': node.get_option_value('number'),
'numbering': node.numbering}
self._options['ids'].append(data)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('toc', TocNode)
class HyperlinkHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for hyperlinks.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node: HyperlinkNode, file: Any) -> None:
"""
Generates the HTML code for a hyperlink node.
:param HyperlinkNode node: The hyperlink node.
:param any file: The output file.
"""
file.write(HyperlinkHtmlFormatter.get_html(node))
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_html(node: HyperlinkNode) -> str:
"""
Returns string with generated HTML tag.
:param HyperlinkNode node: The hyperlink node.
"""
return Html.generate_element('a', node.get_html_attributes(),
node.argument)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('hyperlink', 'html', HyperlinkHtmlFormatter)
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('hyperlink', HyperlinkNode)
return 'part'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level=-1):
"""
Returns 0.
:rtype: int
"""
return 0
# ------------------------------------------------------------------------------------------------------------------
def number(self, enumerable_numbers):
"""
Sets number of heading nodes.
:param dict[str,sdoc.sdoc2.helper.Enumerable.Enumerable] enumerable_numbers:
"""
if 'part' not in enumerable_numbers:
enumerable_numbers['part'] = Enumerable()
enumerable_numbers['part'].generate_numeration(self.get_hierarchy_level())
enumerable_numbers['part'].increment_last_level()
enumerable_numbers['part'].remove_starting_zeros()
super().number(enumerable_numbers)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('part', PartNode)
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self):
"""
Returns True.
:rtype: bool
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('ref', ReferenceNode)
"""
return 'part'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 0.
"""
return 0
# ------------------------------------------------------------------------------------------------------------------
def number(self, enumerable_numbers: Dict[str, Any]) -> None:
"""
Sets number of heading nodes.
:param dict[str,any] enumerable_numbers:
"""
if 'part' not in enumerable_numbers:
enumerable_numbers['part'] = Enumerable()
enumerable_numbers['part'].generate_numeration(
self.get_hierarchy_level())
enumerable_numbers['part'].increment_last_level()
enumerable_numbers['part'].remove_starting_zeros()
super().number(enumerable_numbers)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('part', PartNode)
def _create_node_store(self) -> None:
"""
Creates the node store (for storing nodes).
"""
sdoc2.node_store = NodeStore(self._io)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def write_into_file(node, file):
"""
Writes data into opened file.
:param sdoc.sdoc2.node.ReferenceNode.ReferenceNode node: The reference node.
:param file file: The output file.
"""
file.write(ReferenceHtmlFormatter.get_html(node))
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_html(node):
"""
Returns string with generated HTML tag.
:param sdoc.sdoc2.node.ReferenceNode.ReferenceNode node: The reference node.
:rtype: str
"""
attributes = {'class': node.get_option_value('class'),
'href': node.get_option_value('href'),
'title': node.get_option_value('title')}
return Html.generate_element('a', attributes, str(node.text))
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('ref', 'html', ReferenceHtmlFormatter)
Copyright 2016 Set Based IT Consultancy
Licence MIT
"""
# ----------------------------------------------------------------------------------------------------------------------
from sdoc.sdoc2.NodeStore import NodeStore
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
class ParagraphHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for paragraph.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node, file):
"""
Generates the HTML code for a paragraph node.
:param sdoc.sdoc2.node.ParagraphNode.ParagraphNode node: The paragraph node.
:param file file: The output file.
"""
file.write('<p>')
HtmlFormatter.generate(self, node, file)
file.write('</p>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('paragraph', 'html', ParagraphHtmlFormatter)
def get_command(self) -> str:
"""
Returns the command of this node, i.e. br.
"""
return 'br'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self) -> bool:
"""
Returns True.
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('br', LineBreakNode)
def set_toc_id(self) -> None:
"""
Don't do anything. Because we needn't this behaviour here.
"""
pass
# ------------------------------------------------------------------------------------------------------------------
def prune_whitespace(self) -> None:
"""
Removes spaces from end of a paragraph.
"""
first = self.child_nodes[0]
last = self.child_nodes[-1]
for node_id in self.child_nodes:
node = in_scope(node_id)
if isinstance(node, TextNode):
if node.id == first:
node.prune_whitespace(leading=True)
if node.id == last:
node.prune_whitespace(trailing=True)
if node.id != last and node.id != first:
node.prune_whitespace()
out_scope(node)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('paragraph', ParagraphNode)
Copyright 2016 Set Based IT Consultancy
Licence MIT
"""
# ----------------------------------------------------------------------------------------------------------------------
from sdoc.helper.Html import Html
from sdoc.sdoc2.NodeStore import NodeStore
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
class TextHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for text.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node, file):
"""
Generates the HTML code for a text node.
:param sdoc.sdoc2.node.TextNode.TextNode node: The text node.
:param file file: The output file.
"""
file.write(Html.escape(node.argument))
HtmlFormatter.generate(self, node, file)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('TEXT', 'html', TextHtmlFormatter)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def level_up(numbers):
"""
Increments the level of hierarchy.
:param dict[str,str] numbers: The number of last node.
"""
if 'item' in numbers:
numbers['item'] += '.0'
else:
numbers['item'] = '0'
# ------------------------------------------------------------------------------------------------------------------
def number(self, numbers):
"""
Passing over all child nodes, for numeration.
:param dict[str,str] numbers: The number of last node.
"""
self.level_up(numbers)
super().number(numbers)
numbers['item'] = self.level_down(numbers['item'])
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('itemize', ItemizeNode)
def get_command(self) -> str:
"""
Returns the command of this node, i.e. hyperlink.
"""
return 'hyperlink'
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('hyperlink', HyperlinkNode)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def __check_document_info(info_node_current, info_node_new):
"""
Checks if a document info node has been set already. If so, an error will be logged.
:param int|None info_node_current: The current document info node (i.e. a property of the document).
:param sdoc.sdoc2.node.Node.Node info_node_new: The (new) document info node.
"""
if info_node_current:
node = in_scope(info_node_current)
position = node.position
out_scope(node)
NodeStore.error("Document info {0} can be specified only once. Previous definition at {1}.".format(
info_node_new.name, str(position)), info_node_new)
# ------------------------------------------------------------------------------------------------------------------
def __remove_document_info_nodes(self):
"""
Removes the nodes with document info from the list of child nodes.
"""
obsolete_node_ids = [self.date_node_id, self.title_node_id, self.version_node_id]
obsolete_node_ids = [node_id for node_id in obsolete_node_ids if node_id is not None]
self._remove_child_nodes(obsolete_node_ids)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('document', DocumentNode)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def add_definition(name: str, attributes: Dict[str, str]):
"""
Adds the definition of an icon to the icon definitions.
:param str name: The name of a reference to icon definition.
:param dict[str,str] attributes: The attributes.
"""
IconNode._definitions[name] = attributes
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_definition(name: str) -> Optional[Dict[str, str]]:
"""
Returns the attributes of a definition, if name of definition is exists.
:param str name: The name of a definition
:rtype: dict[str,str]|None
"""
if name in IconNode._definitions:
return IconNode._definitions[name]
else:
return None
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('icon', IconNode)
from typing import Any
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
from sdoc.sdoc2.node.ItemizeNode import ItemizeNode
from sdoc.sdoc2.NodeStore import NodeStore
class ItemizeHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for itemize.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node: ItemizeNode, file: Any) -> None:
"""
Generates the HTML code for an itemize node.
:param ItemizeNode node: The itemize node.
:param any file: The output file.
"""
file.write('<ul>')
HtmlFormatter.generate(self, node, file)
file.write('</ul>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('itemize', 'html', ItemizeHtmlFormatter)
def get_command(self) -> str:
"""
Returns the command of this node, i.e. title.
"""
return 'title'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 0.
"""
return 0
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('title', TitleNode)
Object constructor.
:param None|cleo.styles.output_style.OutputStyle io: The IO object.
:param dict[str,str] options: The options of this section.
:param str argument: The title of this section.
"""
super().__init__(io, 'sub2section', options, argument)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self):
"""
Returns the command of this node, i.e. sub2section.
:rtype: str
"""
return 'sub2section'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level=-1):
"""
Returns 4.
:rtype: int
"""
return 4
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('sub2section', Sub2SectionNode)
NodeStore.register_inline_command('subsubsection', Sub2SectionNode)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self):
"""
Returns the command of this node, i.e. caption.
:rtype: str
"""
return 'caption'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('caption', CaptionNode)
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self):
"""
Returns True.
:rtype: bool
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('date', DateNode)
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self):
"""
Returns True.
:rtype: bool
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('version', VersionNode)
def set_toc_id(self):
"""
Don't do anything. Because we needn't this behaviour here.
"""
pass
# ------------------------------------------------------------------------------------------------------------------
def prune_whitespace(self):
"""
Removes spaces from end of a paragraph.
"""
first = self.child_nodes[0]
last = self.child_nodes[-1]
for node_id in self.child_nodes:
node = in_scope(node_id)
if isinstance(node, TextNode):
if node.id == first:
node.prune_whitespace(leading=True)
if node.id == last:
node.prune_whitespace(trailing=True)
if node.id != last and node.id != first:
node.prune_whitespace()
out_scope(node)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('paragraph', ParagraphNode)
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 0.
"""
return 0
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self) -> bool:
"""
Returns True.
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('date', DateNode)
"""
return 'icondef'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def prepare_content_tree(self) -> None:
"""
Prepares this node for further processing.
"""
reference_name = self.argument
attributes = self._options
IconNode.add_definition(reference_name, attributes)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('icondef', IconDefNode)
"""
# ------------------------------------------------------------------------------------------------------------------
def __init__(self, io: OutputStyle, options: Dict[str, str], argument: str):
"""
Object constructor.
:param OutputStyle io: The IO object.
:param dict[str,str] options: The options of this section.
:param str argument: The title of this section.
"""
super().__init__(io, 'section', options, argument)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self) -> str:
"""
Returns the command of this node, i.e. section.
"""
return 'section'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 2.
"""
return 2
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('section', SectionNode)
# ------------------------------------------------------------------------------------------------------------------
def __init__(self, io: OutputStyle, options: Dict[str, str], argument: str):
"""
Object constructor.
:param OutputStyle io: The IO object.
:param dict[str,str] options: The options of this section.
:param str argument: The title of this section.
"""
super().__init__(io, 'subsection', options, argument)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self) -> str:
"""
Returns the command of this node, i.e. subsection.
"""
return 'subsection'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 3.
"""
return 3
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('sub1section', Sub1SectionNode)
NodeStore.register_inline_command('subsection', Sub1SectionNode)
TocHtmlFormatter.write_elements(item, file)
elif not depth:
TocHtmlFormatter.write_elements(item, file)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def write_elements(item, file):
"""
Write the containing elements.
:param dict[str,str] item: The item which we outputs.
:param file file: The output file.
"""
class_attr = 'level{}'.format(item['level'])
file.write(Html.generate_tag('li', {'class': class_attr}))
file.write(Html.generate_tag('a', {'href': '#{}'.format(item['id'])}))
number = item['number'] if item['numbering'] else None
if number:
file.write(Html.generate_element('span', {}, str(number)))
file.write(' {}'.format(item['arg']))
file.write('</a>')
file.write('</li>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('toc', 'html', TocHtmlFormatter)
HtmlFormatter for generating HTML code for smile.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node, file):
"""
Generates the HTML code for a smile node.
:param sdoc.sdoc2.node.SmileNode.SmileNode node: The smile node.
:param file file: The output file.
"""
file.write(SmileHtmlFormatter.get_html(node))
HtmlFormatter.generate(self, node, file)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_html(node):
"""
Returns string with generated HTML tag.
:param sdoc.sdoc2.node.SmileNode.SmileNode node: The smile node.
:rtype: str
"""
return Html.generate_element('b', {}, 'SMILE')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('smile', 'html', SmileHtmlFormatter)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def strip_start_point(number):
"""
Removes start point if it in the number.
:param str number: The number of last node.
:rtype: str
"""
return number.lstrip('.')
# ------------------------------------------------------------------------------------------------------------------
def number(self, numbers):
"""
Sets number for item nodes.
:param dict[str,str] numbers: The number of last node.
"""
numbers['item'] = self.strip_start_point(numbers['item'])
numbers['item'] = self._increment_last_level(numbers['item'])
self._options['number'] = numbers['item']
super().number(numbers)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('item', ItemNode)
from typing import Any
from sdoc.helper.Html import Html
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
from sdoc.sdoc2.node.TitleNode import TitleNode
from sdoc.sdoc2.NodeStore import NodeStore
class TitleHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for title of SDoc document.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node: TitleNode, file: Any) -> None:
"""
Generates HTML code for a title node.
:param TitleNode node: The title node.
:param any file: The output file.
"""
html_code = Html.generate_element('span', {}, node.argument)
file.write(html_code)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('title', 'html', TitleHtmlFormatter)
from typing import Any
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
from sdoc.sdoc2.node.LabelNode import LabelNode
from sdoc.sdoc2.NodeStore import NodeStore
class LabelHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for labels.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node: LabelNode, file: Any) -> None:
"""
Generates the HTML code for a label node.
:param LabelNode node: The label node.
:param any file: The output file.
"""
HtmlFormatter.generate(self, node, file)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('label', 'html', LabelHtmlFormatter)
class HyperlinkHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for hyperlinks.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node, file):
"""
Generates the HTML code for a hyperlink node.
:param sdoc.sdoc2.node.HyperlinkNode.HyperlinkNode node: The hyperlink node.
:param file file: The output file.
"""
file.write(HyperlinkHtmlFormatter.get_html(node))
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_html(node):
"""
Returns string with generated HTML tag.
:param sdoc.sdoc2.node.HyperlinkNode.HyperlinkNode node: The hyperlink node.
:rtype: str
"""
return Html.generate_element('a', node.get_html_attributes(), node.argument)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('hyperlink', 'html', HyperlinkHtmlFormatter)
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def generate_toc(self):
"""
Generates the table of contents.
"""
self._options['ids'] = []
for node in node_store.nodes.values():
if not isinstance(node, ParagraphNode) and isinstance(node, HeadingNode):
node.set_toc_id()
data = {'id': node.get_option_value('id'),
'arg': node.argument,
'level': node.get_hierarchy_level(),
'number': node.get_option_value('number'),
'numbering': node.numbering}
self._options['ids'].append(data)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('toc', TocNode)
def get_command(self) -> str:
"""
Returns the command of this node, i.e. reference.
"""
return 'ref'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self) -> bool:
"""
Returns True.
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('ref', ReferenceNode)
Checks if a document info node has been set already. If so, an error will be logged.
:param int|None info_node_current: The current document info node (i.e. a property of the document).
:param Node info_node_new: The (new) document info node.
"""
if info_node_current:
node = in_scope(info_node_current)
position = node.position
out_scope(node)
NodeStore.error(
"Document info {0} can be specified only once. Previous definition at {1}."
.format(info_node_new.name, str(position)), info_node_new)
# ------------------------------------------------------------------------------------------------------------------
def __remove_document_info_nodes(self):
"""
Removes the nodes with document info from the list of child nodes.
"""
obsolete_node_ids = [
self.date_node_id, self.title_node_id, self.version_node_id
]
obsolete_node_ids = [
node_id for node_id in obsolete_node_ids if node_id is not None
]
self._remove_child_nodes(obsolete_node_ids)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('document', DocumentNode)
"""
SDoc
Copyright 2016 Set Based IT Consultancy
Licence MIT
"""
# ----------------------------------------------------------------------------------------------------------------------
from sdoc.sdoc2.NodeStore import NodeStore
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
class IconDefHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter stub for definition of the Icon.
"""
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('icondef', 'html', IconDefHtmlFormatter)
def is_block_command(self):
"""
Returns False.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self):
"""
Returns True.
:rtype: bool
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_phrasing(self):
"""
Returns True.
:rtype: bool
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('unknown', UnknownNode)
NodeStore.register_inline_command('unknown', UnknownNode)
alignments.append('center')
elif hyphens.startswith(':'):
alignments.append('left')
elif hyphens.endswith(':'):
alignments.append('right')
else:
alignments.append('')
return alignments
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def prune_whitespace(row):
"""
Strips whitespaces from the text of an each cell.
:param list[str] row: The row with text of an each cell.
:rtype: list[str]
"""
clear_row = []
for item in row:
clear_text = item.strip()
clear_text = re.sub(r'\s+', ' ', clear_text)
clear_row.append(clear_text)
return clear_row
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_block_command('table', TableNode)
Returns the command of this node, i.e. end_paragraph.
:rtype: str
"""
return 'end_paragraph'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def prepare_content_tree(self) -> None:
"""
Not implemented for end paragraph nodes.
"""
raise RuntimeError()
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('end_paragraph', EndParagraphNode)
:param sdoc.sdoc2.node.DocumentNode.DocumentNode node: The document node.
:param file file: The output file.
"""
file.write('<div class="sdoc-document-title-outer">')
if node.title_node_id:
title_node = in_scope(node.title_node_id)
file.write(Html.generate_element('h1', {}, title_node.argument))
out_scope(title_node)
file.write('<div class="sdoc-document-title-inner">')
if node.date_node_id:
date_node = in_scope(node.date_node_id)
if date_node.argument:
file.write(Html.generate_element('span', {'class': 'sdoc-document-date'}, date_node.argument))
out_scope(date_node)
if node.version_node_id:
version_node = in_scope(node.version_node_id)
if version_node.argument:
file.write(Html.generate_element('span', {'class': 'sdoc-document-version'}, version_node.argument))
out_scope(version_node)
file.write('</div>')
file.write('</div>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('document', 'html', DocumentHtmlFormatter)
title_node = in_scope(node.title_node_id)
file.write(Html.generate_element('h1', {}, title_node.argument))
out_scope(title_node)
file.write('<div class="sdoc-document-title-inner">')
if node.date_node_id:
date_node = in_scope(node.date_node_id)
if date_node.argument:
file.write(
Html.generate_element('span',
{'class': 'sdoc-document-date'},
date_node.argument))
out_scope(date_node)
if node.version_node_id:
version_node = in_scope(node.version_node_id)
if version_node.argument:
file.write(
Html.generate_element('span',
{'class': 'sdoc-document-version'},
version_node.argument))
out_scope(version_node)
file.write('</div>')
file.write('</div>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('document', 'html', DocumentHtmlFormatter)
from typing import Any
from sdoc.helper.Html import Html
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
from sdoc.sdoc2.node.DateNode import DateNode
from sdoc.sdoc2.NodeStore import NodeStore
class DateHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter for generating HTML code for date of SDoc document.
"""
# ------------------------------------------------------------------------------------------------------------------
def generate(self, node: DateNode, file: Any) -> None:
"""
Generates HTML code for a date node.
:param DateNode node: The date node.
:param any file: The output file.
"""
html = Html.generate_element('span', {}, node.argument)
file.write(html)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('date', 'html', DateHtmlFormatter)
:param OutputStyle io: The IO object.
:param dict[str,str] options: The options of this label.
:param str argument: The title of this label.
"""
super().__init__(io, 'label', options, argument)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self) -> str:
"""
Returns the command of this node, i.e. label.
"""
return 'label'
# ------------------------------------------------------------------------------------------------------------------
def is_block_command(self) -> bool:
"""
Returns False.
"""
return False
# ------------------------------------------------------------------------------------------------------------------
def is_inline_command(self) -> bool:
"""
Returns True.
"""
return True
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('label', LabelNode)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def write_into_file(node, file):
"""
Writes data into opened HTML file.
:param sdoc.sdoc2.node.FigureNode.FigureNode node: The figure node.
:param file file: The output file.
"""
# Creating dicts with attributes for each type of element.
figure_attributes = {'id': node.get_option_value('id')}
img_attributes = {'src': node.get_option_value('src'),
'width': node.get_option_value('width'),
'height': node.get_option_value('height'),
'alt': node.caption}
# Creating elements.
file.write(Html.generate_tag('figure', figure_attributes))
file.write(Html.generate_void_element('img', img_attributes))
FigureHtmlFormatter._write_caption(node, file)
file.write('</figure>')
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('figure', 'html', FigureHtmlFormatter)
Generates the HTML code for an unknown node.
:param sdoc.sdoc2.node.Node.Node node: The unknown node.
:param file file: The output file.
"""
self.write_into_file(node)
# ------------------------------------------------------------------------------------------------------------------
def generate_chapter(self, node, file):
"""
Generates the HTML code for an unknown node.
:param sdoc.sdoc2.node.Node.Node node: The unknown node.
:param file file: The output file.
"""
if file:
self.write_into_file(node)
# ------------------------------------------------------------------------------------------------------------------
def write_into_file(self, node):
"""
Writes into opened file.
:param sdoc.sdoc2.node.Node.Node node: The unknown node.
"""
self.error('Unknown SDoc2 command {0}'.format(node.name), node)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('unknown', 'html', UnknownHtmlFormatter)
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def add_definition(name, attributes):
"""
Adds the definition of an icon to the icon definitions.
:param str name: The name of a reference to icon definition.
:param dict[str,dict[str,str]] attributes: The attributes.
"""
IconNode._definitions[name] = attributes
# ------------------------------------------------------------------------------------------------------------------
@staticmethod
def get_definition(name):
"""
Returns the attributes of a definition, if name of definition is exists.
:param str name: The name of a definition
:rtype: dict[str,str]|None
"""
if name in IconNode._definitions:
return IconNode._definitions[name]
else:
return None
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('icon', IconNode)
from sdoc.sdoc2.formatter.html.HtmlFormatter import HtmlFormatter
from sdoc.sdoc2.NodeStore import NodeStore
class CaptionHtmlFormatter(HtmlFormatter):
"""
HtmlFormatter stub generating HTML code for captions.
"""
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_formatter('caption', 'html', CaptionHtmlFormatter)
sdoc.sdoc2.node_store.store_node(text_node)
text_ids.append(text_node.id)
end_paragraph_node = sdoc.sdoc2.node_store.create_inline_node('end_paragraph')
text_ids.append(end_paragraph_node.id)
# Checking where we need to add paragraph.
if text_ids:
if list_of_texts[-1]:
text_ids.pop()
return text_ids
# ------------------------------------------------------------------------------------------------------------------
def prune_whitespace(self, leading=False, trailing=False):
"""
Method for removing whitespace in text.
:param bool leading: if True, remove whitespaces from start.
:param bool trailing: if True, remove whitespaces from end.
"""
if leading:
self._argument = self._argument.lstrip()
if trailing:
self._argument = self._argument.rstrip()
self._argument = re.sub(r'\s+', ' ', self._argument)
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('TEXT', TextNode)
# ------------------------------------------------------------------------------------------------------------------
def __init__(self, io: OutputStyle, options: Dict[str, str],
argument: str):
"""
Object constructor.
:param OutputStyle io: The IO object.
:param dict[str,str] options: The options of this chapter.
:param str argument: The title of this chapter.
"""
super().__init__(io, 'chapter', options, argument)
# ------------------------------------------------------------------------------------------------------------------
def get_command(self) -> str:
"""
Returns the command of this node, i.e. chapter.
"""
return 'chapter'
# ------------------------------------------------------------------------------------------------------------------
def get_hierarchy_level(self, parent_hierarchy_level: int = -1) -> int:
"""
Returns 1.
"""
return 1
# ----------------------------------------------------------------------------------------------------------------------
NodeStore.register_inline_command('chapter', ChapterNode)
