doorstop.core.publishers.base

Complexity

Total Complexity

59

Size/Duplication

Total Lines	323
Duplicated Lines	0 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	BasePublisher.getLinkify()	0	3	1
A	BasePublisher.publishAction()	0	8	1
A	BasePublisher._check_for_list_end()	0	13	4
A	BasePublisher.setup()	0	14	4
A	BasePublisher.getIndex()	0	3	1
A	BasePublisher.preparePublish()	0	2	1
A	BasePublisher.format_references()	0	4	1
A	BasePublisher.getTemplate()	0	3	1
A	BasePublisher.format_attr_list()	0	4	1
C	BasePublisher.table_of_contents()	0	35	9
A	BasePublisher.getAssetsPath()	0	3	1
F	BasePublisher.process_lists()	0	57	14
A	BasePublisher.format_ref()	0	4	1
A	BasePublisher.format_links()	0	6	1
A	BasePublisher.create_matrix()	0	3	1
A	BasePublisher.lines()	0	11	1
A	BasePublisher.create_index()	0	13	1
A	BasePublisher.concludePublish()	0	2	1
A	BasePublisher.setPath()	0	3	1
A	BasePublisher.get_line_generator()	0	3	1
A	BasePublisher.format_label_links()	0	6	1
A	BasePublisher.getDocumentPath()	0	3	1
A	BasePublisher.processTemplates()	0	4	1
A	BasePublisher.getMatrix()	0	3	1
A	BasePublisher.format_item_link()	0	6	1
A	BasePublisher.__init__()	0	25	1

# SPDX-License-Identifier: LGPL-3.0-only

"""Abstract interface to publishers."""

from abc import ABCMeta, abstractmethod
from re import compile as re_compile
from typing import Any, Dict

from doorstop import common, settings
from doorstop.common import DoorstopError
from doorstop.core.template import get_template
from doorstop.core.types import is_tree, iter_items

log = common.logger(__name__)


class BasePublisher(metaclass=ABCMeta):
    """Abstract base class for publishers.

    All functions marked as @abstractmethod must be defined by the publisher
    class.

    All other functions are standard and _can_ be overridden _if needed_.
    """

    def __init__(self, obj, ext):
        """Initialize publisher class."""
        self.object = obj
        self.ext = ext
        self.path = ""
        self.document = None
        self.documentPath = ""
        self.assetsPath = ""
        self.template = ""
        self.linkify = None
        self.index = None
        self.matrix = None
        # Define lists.
        self.list: Dict[str, Dict[str, Any]] = {}
        self.list["depth"] = {"itemize": 0, "enumerate": 0}
        self.list["indent"] = {"itemize": 0, "enumerate": 0}
        self.list["found"] = {"itemize": False, "enumerate": False}
        # Create regexps.
        self.list["regexp"] = {
            "itemize": re_compile(r"^\s*[\*+-]\s(.*)"),
            "enumerate": re_compile(r"^\s*\d+\.\s(.*)"),
        }
        self.list["sub"] = {
            "itemize": re_compile(r"^\s*[\*+-]\s"),
            "enumerate": re_compile(r"^\s*\d+\.\s"),
        }

    def setup(self, linkify, index, matrix):
        """Check and store linkfy, index and matrix settings."""
        if linkify is None:
            self.linkify = is_tree(self.object) and self.ext in [".html", ".md", ".tex"]
        else:
            self.linkify = linkify
        if index is None:
            self.index = is_tree(self.object) and self.ext == ".html"
        else:
            self.index = index
        if matrix is None:
            self.matrix = is_tree(self.object)
        else:
            self.matrix = matrix

    def preparePublish(self):
        """Prepare publish.

        Replace this with code that should be run _before_ a document or tree
        is published.
        """

    def publishAction(self, document, path):
        """Publish action.

        Replace this with code that should be run _for each_ document
        _during_ publishing.
        """
        self.document = document
        self.documentPath = path

    def concludePublish(self):
        """Conclude publish.

        Replace this with code that should be run _after_ a document or tree
        is published.
        """

    def table_of_contents(self, linkify=None, obj=None):
        toc = "### Table of Contents\n\n"
        if obj is None:
            toc_doc = self.object
        else:
            toc_doc = obj

        for item in iter_items(toc_doc):
            if item.depth == 1:
                prefix = " * "
            else:
                prefix = "    " * (item.depth - 1)
                prefix += "* "

            # Check if item has the attribute heading.
            if item.heading:
                lines = item.text.splitlines()
                heading = lines[0] if lines else ""
            elif item.header:
                heading = "{h}".format(h=item.header)
            else:
                heading = item.uid

            if settings.PUBLISH_HEADING_LEVELS:
                level = format_level(item.level)
                lbl = "{lev} {h}".format(lev=level, h=heading)
            else:
                lbl = heading

            if linkify:
                line = "{p}[{lbl}](#{uid})\n".format(p=prefix, lbl=lbl, uid=item.uid)
            else:
                line = "{p}{lbl}\n".format(p=prefix, lbl=lbl)
            toc += line
        return toc

    @abstractmethod
    def lines(self, obj, **kwargs):  # pragma: no cover (abstract method)
        """Yield lines for a report.

        :param obj: Item, list of Items, or Document to publish
        :param linkify: turn links into hyperlinks

        :return: iterator of lines of text

        """
        raise NotImplementedError

    @abstractmethod
    def create_index(
        self, directory, index=None, extensions=(".html",), tree=None
    ):  # pragma: no cover (abstract method)
        """Create an index of all files in a directory.

        :param directory: directory for index
        :param index: filename for index
        :param extensions: file extensions to include
        :param tree: optional tree to determine index structure

        """
        raise NotImplementedError

    def create_matrix(self, directory):  # pragma: no cover (abstract method)
        """Create a traceability table."""
        raise NotImplementedError

    @abstractmethod
    def format_attr_list(self, item, linkify):  # pragma: no cover (abstract method)
        """Create an attribute list for a heading."""
        raise NotImplementedError

    @abstractmethod
    def format_ref(self, item):  # pragma: no cover (abstract method)
        """Format an external reference."""
        raise NotImplementedError

    @abstractmethod
    def format_references(self, item):  # pragma: no cover (abstract method)
        """Format an external reference."""
        raise NotImplementedError

    @abstractmethod
    def format_links(
        self, items, linkify, to_html=False
    ):  # pragma: no cover (abstract method)
        """Format a list of linked items."""
        raise NotImplementedError

    @abstractmethod
    def format_item_link(
        self, item, linkify=True
    ):  # pragma: no cover (abstract method)
        """Format an item link."""
        raise NotImplementedError

    @abstractmethod
    def format_label_links(
        self, label, links, linkify
    ):  # pragma: no cover (abstract method)
        """Join a string of label and links with formatting."""
        raise NotImplementedError

    def get_line_generator(self):
        """Return the lines generator for the class."""
        return self.lines

    def setPath(self, path):
        """Set the export path of the tree and/or document."""
        self.path = path

    def getDocumentPath(self):
        """Get the export path of the individual document."""
        return self.documentPath

    def processTemplates(self, template):
        """Retrieve the template and its path."""
        self.assetsPath, self.template = get_template(
            self.object, self.path, self.ext, template
        )

    def getAssetsPath(self):
        """Get the assets path of the individual document."""
        return self.assetsPath

    def getTemplate(self):
        """Get the template."""
        return self.template

    def getIndex(self):
        """Get the index flag."""
        return self.index

    def getMatrix(self):
        """Get the matrix flag."""
        return self.matrix

    def getLinkify(self):
        """Get the linkify flag."""
        return self.linkify

    def process_lists(self, line, next_line):
        """Process lists in the line. Intended for LaTeX and HTML publishers."""
        # Don't process custom attributes.
        if "CUSTOM-ATTRIB" in line:
            return (False, "", line)
        # Loop over both list types.
        for temp_type in ["itemize", "enumerate"]:
            matches = self.list["regexp"][temp_type].findall(line)
            if matches:
                list_type = temp_type
                # Cannot have both types on the same line.
                break
        block = []
        no_paragraph = False
        if matches:

The variable matches does not seem to be defined in case the for loop on line 237 is not entered. Are you sure this can never be the case?

            indent = len(line) - len(line.lstrip())
            if not self.list["found"][list_type]:

The variable list_type does not seem to be defined for all execution paths.

                block.append(self.list["start"][list_type])
                self.list["found"][list_type] = True
                self.list["depth"][list_type] = indent
            elif self.list["depth"][list_type] < indent:
                block.append(self.list["start"][list_type])
                if self.list["depth"][list_type] == 0:
                    self.list["indent"][list_type] = indent
                elif (
                    self.list["depth"][list_type] + self.list["indent"][list_type]
                    != indent
                ):
                    raise DoorstopError(
                        "Cannot change indentation depth inside a list."
                    )
                self.list["depth"][list_type] = indent
            elif self.list["depth"][list_type] > indent:
                while self.list["depth"][list_type] > indent:
                    block.append(self.list["end"][list_type])
                    self.list["depth"][list_type] = (
                        self.list["depth"][list_type] - self.list["indent"][list_type]
                    )
        # Check both list types.
        for list_type in ["itemize", "enumerate"]:
            if self.list["found"][list_type]:
                no_paragraph = True
                # Replace the list identifier.
                line = (
                    self.list["sub"][list_type].sub(
                        self.list["start_item"][list_type], line
                    )
                    + self.list["end_item"][list_type]
                )
                # Look ahead - need empty line to end itemize!
                (block, line) = self._check_for_list_end(
                    line, next_line, block, list_type
                )
        if len(block) > 0:
            return (no_paragraph, "\n".join(block), line)
        else:
            return (no_paragraph, "", line)

    def _check_for_list_end(self, line, next_line, block, list_type):
        """Check if the list has ended."""
        if next_line == "" or next_line.startswith("<p>"):
            block.append(line)
            while self.list["depth"][list_type] > 0:
                block.append(self.list["end"][list_type])
                self.list["depth"][list_type] = (
                    self.list["depth"][list_type] - self.list["indent"][list_type]
                )
            line = self.list["end"][list_type]
            self.list["found"][list_type] = False
            self.list["depth"][list_type] = 0
        return (block, line)


def extract_prefix(document):
    """Return the document prefix."""
    return document.prefix


def extract_uid(item):
    """Return the item uid."""
    if item:
        return item.uid
    else:
        return None


def format_level(level):
    """Convert a level to a string and keep zeros if not a top level."""
    text = str(level)
    if text.endswith(".0") and len(text) > 3:
        text = text[:-2]
    return text