syntax_plugin_yalist::renderOdtItem() - Code Metrics - Inspection of "Merge pull request #21 from mprins/github-actions" - mprins/dokuwiki-yalist-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 05662d...8d2287 )

by Mark
created 2021-04-14 08:38 UTC
syntax_plugin_yalist::renderOdtItem() F

↳ Parent: syntax_plugin_yalist
Complexity

Conditions	60
Paths	79
Size

Total Lines
259
Duplication

Lines	50
Ratio	19.31 %
Importance

Changes
Metric	Value
dl	50
loc	259
rs	3.3333
c	0
b	0
f	0
cc	60
nc	79
nop	2
How to fix Long Method Complexity

<?php
/*
 * This plugin extends DokuWiki's list markup syntax to allow definition lists
 * and list items with multiple paragraphs. The complete syntax is as follows:
 *
 *
 *   - ordered list item            [<ol><li>]  <!-- as standard syntax -->
 *   * unordered list item          [<ul><li>]  <!-- as standard syntax -->
 *   ? definition list term         [<dl><dt>]
 *   : definition list definition   [<dl><dd>]
 *
 *   -- ordered list item w/ multiple paragraphs
 *   ** unordered list item w/ multiple paragraphs
 *   :: definition list definition w/multiple paragraphs
 *   .. new paragraph in --, **, or ::
 *
 *
 * Lists can be nested within lists, just as in the standard DokuWiki syntax.
 *
 * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)
 * @author     Ben Slusky <[email protected]>
 *
 */
class syntax_plugin_yalist extends DokuWiki_Syntax_Plugin {
    private $stack = array();
    private static $odt_table_stack = array();
    private static $odt_table_stack_index = 0;

    public function getType() {
        return 'container';
    }

    public function getSort() {
        // just before listblock (10)
        return 9;
    }

    public function getPType() {
        return 'block';
    }

    public function getAllowedTypes() {
        return array('substition', 'protected', 'disabled', 'formatting');
    }

    public function connectTo($mode) {
        $this->Lexer->addEntryPattern('\n {2,}(?:--?|\*\*?|\?|::?)', $mode, 'plugin_yalist');
        $this->Lexer->addEntryPattern('\n\t{1,}(?:--?|\*\*?|\?|::?)', $mode, 'plugin_yalist');
        $this->Lexer->addPattern('\n {2,}(?:--?|\*\*?|\?|::?|\.\.)', 'plugin_yalist');
        $this->Lexer->addPattern('\n\t{1,}(?:--?|\*\*?|\?|::?|\.\.)', 'plugin_yalist');
    }

    public function postConnect() {
        $this->Lexer->addExitPattern('\n', 'plugin_yalist');
    }

    public function handle($match, $state, $pos, Doku_Handler $handler) {
        $output = array();
        $level = 0;
        switch ($state) {
            case DOKU_LEXER_ENTER:
                $frame = $this->interpretMatch($match);
                $level = $frame['level'] = 1;
                array_push($output,
                            "${frame['list']}_open",
                        "${frame['item']}_open",
                        "${frame['item']}_content_open");
            if ($frame['paras']) {
                            array_push($output, 'p_open');
            }
            array_push($this->stack, $frame);
            break;
        case DOKU_LEXER_EXIT:
            $close_content = true;
            while ($frame = array_pop($this->stack)) {
                // for the first frame we pop off the stack, we'll need to
                // close the content tag; for the rest it will have been
                // closed already
                if ($close_content) {
                    if ($frame['paras']) {
                                            array_push($output, 'p_close');
                    }
                    array_push($output, "${frame['item']}_content_close");
                    $close_content = false;
                }
                array_push($output,
                            "${frame['item']}_close",
                            "${frame['list']}_close");
            }
            break;
        case DOKU_LEXER_MATCHED:
            $last_frame = end($this->stack);
            if (substr($match, -2) == '..') {
                // new paragraphs cannot be deeper than the current depth,
                // but they may be shallower
                $para_depth = count(explode('  ', str_replace("\t", '  ', $match)));
                $close_content = true;
                while ($para_depth < $last_frame['depth'] && count($this->stack) > 1) {

                    if ($close_content) {
                        if ($last_frame['paras']) {
                                                    array_push($output, 'p_close');
                        }
                        array_push($output, "${last_frame['item']}_content_close");
                        $close_content = false;
                    }
                    array_push($output,
                                "${last_frame['item']}_close",
                                "${last_frame['list']}_close");
                    array_pop($this->stack);
                    $last_frame = end($this->stack);
                }
                if ($last_frame['paras']) {
                    if ($close_content) {
                                            // depth did not change
                        array_push($output, 'p_close', 'p_open');
                    } else {
                                            array_push($output,
                                    "${last_frame['item']}_content_open",
                                    'p_open');
                    }
                } else {
                    // let's just pretend we didn't match...
                    $state = DOKU_LEXER_UNMATCHED;
                    $output = $match;
                }
                break;
            }
            $curr_frame = $this->interpretMatch($match);
            if ($curr_frame['depth'] > $last_frame['depth']) {
                // going one level deeper
                $level = $last_frame['level'] + 1;
                if ($last_frame['paras']) {
                                    array_push($output, 'p_close');
                }
                array_push($output,
                            "${last_frame['item']}_content_close",
                            "${curr_frame['list']}_open");
            } else {
                // same depth, or getting shallower
                $close_content = true;
                // keep popping frames off the stack until we find a frame
                // that's at least as deep as this one, or until only the
                // bottom frame (i.e. the initial list markup) remains
                while ($curr_frame['depth'] < $last_frame['depth'] &&

                       count($this->stack) > 1)
                {
                    // again, we need to close the content tag only for
                    // the first frame popped off the stack
                    if ($close_content) {
                        if ($last_frame['paras']) {
                                                    array_push($output, 'p_close');
                        }
                        array_push($output, "${last_frame['item']}_content_close");
                        $close_content = false;
                    }
                    array_push($output,
                                "${last_frame['item']}_close",
                                "${last_frame['list']}_close");
                    array_pop($this->stack);
                    $last_frame = end($this->stack);
                }
                // pull the last frame off the stack;
                // it will be replaced by the current frame
                array_pop($this->stack);
                $level = $last_frame['level'];
                if ($close_content) {
                    if ($last_frame['paras']) {
                                            array_push($output, 'p_close');
                    }
                    array_push($output, "${last_frame['item']}_content_close");
                    $close_content = false;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                }
                array_push($output, "${last_frame['item']}_close");
                if ($curr_frame['list'] != $last_frame['list']) {
                    // change list types
                    array_push($output,
                                "${last_frame['list']}_close",
                                "${curr_frame['list']}_open");
                }
            }
            // and finally, open tags for the new list item
            array_push($output,
                        "${curr_frame['item']}_open",
                        "${curr_frame['item']}_content_open");
            if ($curr_frame['paras']) {
                            array_push($output, 'p_open');
            }
            $curr_frame['level'] = $level;
            array_push($this->stack, $curr_frame);
            break;
        case DOKU_LEXER_UNMATCHED:
            $output = $match;
            break;
        }
        return array('state' => $state, 'output' => $output, 'level' => $level);
    }

    private function interpretMatch($match) {
        $tag_table = array(
            '*' => 'u_li',
            '-' => 'o_li',
            '?' => 'dt',
            ':' => 'dd',
        );
        $tag = $tag_table[substr($match, -1)];
        return array(
            'depth' => count(explode('  ', str_replace("\t", '  ', $match))),
            'list' => substr($tag, 0, 1) . 'l',
            'item' => substr($tag, -2),
            'paras' => (substr($match, -1) == substr($match, -2, 1)),
        );
    }

    public function render($mode, Doku_Renderer $renderer, $data) {
        if ($mode != 'xhtml' && $mode != 'latex' && $mode != 'odt') {
                    return false;
        }
        if ($data['state'] == DOKU_LEXER_UNMATCHED) {
            if ($mode != 'odt') {
                $renderer->doc .= $renderer->_xmlEntities($data['output']);
            } else {
                $renderer->cdata($data['output']);
            }
            return true;
        }
        foreach ($data['output'] as $i) {
            switch ($mode) {
                case 'xhtml':
                    $this->renderXhtmlItem($renderer, $i, $data);
                break;
                case 'latex':
                    $this->renderLatexItem($renderer, $i, $data);
                break;
                case 'odt':
                    $this->renderOdtItem($renderer, $i, $data);
                break;
            }
        }
        if ($data['state'] == DOKU_LEXER_EXIT) {
            if ($mode != 'odt') {
                $renderer->doc .= "\n";
            } else {
                $renderer->linebreak();
            }
        }
        return true;
    }

    private function renderXhtmlItem(Doku_Renderer $renderer, $item, $data) {
        $markup = '';
        switch ($item) {
            case 'ol_open':
                $markup = "<ol>\n";
                break;
            case 'ol_close':
                $markup = "</ol>\n";
                break;
            case 'ul_open':
                $markup = "<ul>\n";
                break;
            case 'ul_close':
                $markup = "</ul>\n";
                break;
            case 'dl_open':
                $markup = "<dl>\n";
                break;
            case 'dl_close':
                $markup = "</dl>\n";
                break;
            case 'li_open':
                $markup = "<li class=\"level${data['level']}\">";
            break;
        case 'li_content_open':
            $markup = "<div class=\"li\">\n";
            break;
        case 'li_content_close':
            $markup = "\n</div>";
            break;
        case 'li_close':
            $markup = "</li>\n";
            break;
        case 'dt_open':
            $markup = "<dt class=\"level${data['level']}\">";
            break;
        case 'dt_content_open':
            $markup = "<span class=\"dt\">";
            break;
        case 'dt_content_close':
            $markup = "</span>";
            break;
        case 'dt_close':
            $markup = "</dt>\n";
            break;
        case 'dd_open':
            $markup = "<dd class=\"level${data['level']}\">";
            break;
        case 'dd_content_open':
            $markup = "<div class=\"dd\">\n";
            break;
        case 'dd_content_close':
            $markup = "\n</div>";
            break;
        case 'dd_close':
            $markup = "</dd>\n";
            break;
        case 'p_open':
            $markup = "<p>\n";
            break;
        case 'p_close':
            $markup = "\n</p>";
            break;
        }
        $renderer->doc .= $markup;
    }

    private function renderLatexItem(Doku_Renderer $renderer, $item) {
        $markup = '';
        switch ($item) {
            case 'ol_open':
                $markup = "\\begin{enumerate}\n";
                break;
            case 'ol_close':
                $markup = "\\end{enumerate}\n";
                break;
            case 'ul_open':
                $markup = "\\begin{itemize}\n";
                break;
            case 'ul_close':
                $markup = "\\end{itemize}\n";
                break;
            case 'dl_open':
                $markup = "\\begin{description}\n";
                break;
            case 'dl_close':
                $markup = "\\end{description}\n";
                break;
            case 'li_open':
                $markup = "\item ";
                break;
            case 'li_content_open':
                break;
            case 'li_content_close':
                break;
            case 'li_close':
                $markup = "\n";
                break;
            case 'dt_open':
                $markup = "\item[";
                break;
            case 'dt_content_open':
                break;
            case 'dt_content_close':
                break;
            case 'dt_close':
                $markup = "] ";
                break;
            case 'dd_open':
                break;
            case 'dd_content_open':
                break;
            case 'dd_content_close':
                break;
            case 'dd_close':
                $markup = "\n";
                break;
            case 'p_open':
                $markup = "\n";
                break;
            case 'p_close':
                $markup = "\n";
                break;
        }
        $renderer->doc .= $markup;
    }

    /**
     * Render yalist items for ODT format
     *
     * @param Doku_Renderer $renderer  The current renderer object
     * @param string        $item      The item to render
     *
     * @author LarsDW223
     */
    private function renderOdtItem(Doku_Renderer $renderer, $item) {
        switch ($item) {
            case 'ol_open':
                $renderer->listo_open();
                break;
            case 'ul_open':
                $renderer->listu_open();
                break;
            case 'dl_open':
                if ($this->getConf('def_list_odt_export') != 'table') {
                    $renderer->listu_open();
                } else {
                    $renderer->table_open(2);
                }
                self::$odt_table_stack [self::$odt_table_stack_index] = array();
                self::$odt_table_stack [self::$odt_table_stack_index]['itemOpen'] = false;
                self::$odt_table_stack [self::$odt_table_stack_index]['dtState'] = 0;
                self::$odt_table_stack [self::$odt_table_stack_index]['ddState'] = 0;
                self::$odt_table_stack_index++;
                break;
            case 'ol_close':
            case 'ul_close':
                $renderer->list_close();
                break;
            case 'dl_close':
                $config = $this->getConf('def_list_odt_export');
                if ($config != 'table') {
                    if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] != 2) {
                        if ($config == 'listheader' && method_exists($renderer, 'listheader_close')) {
                            $renderer->listheader_close();
                        } else {
                            $renderer->listitem_close();
                        }
                    }
                    self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] = 0;
                    $renderer->list_close();
                } else {
                    if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] == 0) {

                        $properties = array();
                        $properties ['border'] = 'none';
                        $renderer->_odtTableCellOpenUseProperties($properties);
                        $renderer->tablecell_close();
                    }
                    self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] = 0;
                    if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                        $renderer->tablerow_close(1);
                        self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                    }
                    $renderer->table_close();
                }
                if (self::$odt_table_stack_index > 0) {
                    self::$odt_table_stack_index--;
                    unset(self::$odt_table_stack [self::$odt_table_stack_index]);
                }
                break;

            case 'li_open':             
                $renderer->listitem_open(1);
                break;
            case 'li_content_open':
                $renderer->listcontent_open();
                break;
            case 'li_content_close':    
                $renderer->listcontent_close();
                break;
            case 'li_close':
                $renderer->listitem_close();
                break;

            case 'dt_open': // unconditional: DT tags can't contain paragraphs. That would not be legal XHTML.
                switch ($this->getConf('def_list_odt_export')) {
                    case 'listheader':
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            if (method_exists($renderer, 'listheader_close')) {
                                $renderer->listheader_close();
                            } else {
                                $renderer->listitem_close();
                            }
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            if (method_exists($renderer, 'listheader_open')) {
                                $renderer->listheader_open(1);
                            } else {
                                $renderer->listitem_open(1);
                            }
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                    break;
                    case 'table':
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] == 0) {

                            $properties = array();
                            $properties ['border'] = 'none';
                            $renderer->_odtTableCellOpenUseProperties($properties);
                            $renderer->tablecell_close();
                        }

                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            $renderer->tablerow_close();
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            $renderer->tablerow_open(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                        $properties = array();
                        $properties ['border'] = 'none';
                        $renderer->_odtTableCellOpenUseProperties($properties);
                    break;
                    default:
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            $renderer->listitem_close();
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            $renderer->listitem_open(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                    break;
                }
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] = 1;
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] = 0;
            break;
            case 'dd_open':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'listheader':

                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            if (method_exists($renderer, 'listheader_open')) {
                                $renderer->listheader_open(1);
                            } else {
                                $renderer->listitem_open(1);
                            }
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                    break;
                    case 'table':
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            $renderer->tablerow_open(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] == 1) {
                            $renderer->tablecell_close();
                        }
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] == 0) {

                            $properties = array();
                            $properties ['border'] = 'none';
                            $renderer->_odtTableCellOpenUseProperties($properties);
                            $renderer->tablecell_close();
                        }

                        $properties = array();
                        $properties ['border'] = 'none';
                        $renderer->_odtTableCellOpenUseProperties($properties);
                    break;
                    default:

                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === false) {
                            $renderer->listitem_open(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = true;
                        }
                    break;
                }
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] = 0;
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] = 1;
            break;
            case 'dt_content_open':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'table':
                        $renderer->p_open();
                    break;
                    default:
                        $renderer->listcontent_open();
                    break;
                }
            $this->renderODTOpenSpan($renderer);
            break;
            case 'dd_content_open':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'table':
                        $renderer->p_open();
                    break;
                    default:
                        $renderer->listcontent_open();
                    break;
                }
            break;
            case 'dt_content_close':
                $this->renderODTCloseSpan($renderer);
                switch ($this->getConf('def_list_odt_export')) {
                    case 'table':
                        $renderer->p_close();
                    break;
                    default:
                        $renderer->listcontent_close();
                    break;
                }
            break;
            case 'dd_content_close':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'table':
                        $renderer->p_close();
                    break;
                    default:
                        $renderer->listcontent_close();
                    break;
                }
            break;
            case 'dt_close':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'listheader':
                        $renderer->linebreak();
                        break;
                    case 'table':
                        $renderer->tablecell_close();
                        self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] = 2;
                        break;
                    default:
                        $renderer->linebreak();
                        break;
                }
            break;

            case 'dd_close':
                switch ($this->getConf('def_list_odt_export')) {
                    case 'listheader':

                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            if (method_exists($renderer, 'listheader_close')) {
                                $renderer->listheader_close();
                            } else {
                                $renderer->listitem_close();
                            }
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        break;
                    case 'table':
                        $renderer->tablecell_close();
                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            $renderer->tablerow_close(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        break;
                    default:

                        if (self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] === true) {
                            $renderer->listitem_close(1);
                            self::$odt_table_stack [self::$odt_table_stack_index - 1]['itemOpen'] = false;
                        }
                        break;
                }
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['dtState'] = 0;
            self::$odt_table_stack [self::$odt_table_stack_index - 1]['ddState'] = 2;
            break;

            case 'p_open':
                $renderer->p_open();
                break;
            case 'p_close':
                $renderer->p_close();
                break;
        }
    }

    /**
     * Open ODT span for rendering of dt-content
     *
     * @param Doku_Renderer $renderer  The current renderer object
     *
     * @author LarsDW223
     */
    private function renderODTOpenSpan($renderer) {
        $properties = array();

        // Get CSS properties for ODT export.
        $renderer->getODTProperties($properties, 'div', 'dokuwiki dt', NULL);

        $renderer->_odtSpanOpenUseProperties($properties);
    }

    /**
     * Close ODT span for rendering of dt-content
     *
     * @param Doku_Renderer $renderer  The current renderer object
     *
     * @author LarsDW223
     */
    private function renderODTCloseSpan($renderer) {
        if (method_exists($renderer, '_odtSpanClose') === false) {
            // Function is not supported by installed ODT plugin version, return.
            return;
        }
        $renderer->_odtSpanClose();
    }
}

mprins / dokuwiki-yalist-plugin

Push — master ( 05662d...8d2287 )

syntax_plugin_yalist::renderOdtItem() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
