Seboettg\CiteProc\Rendering\Layout

Complexity

Total Complexity

34

Size/Duplication

Total Lines	227
Duplicated Lines	5.29 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	12	12	2
D	render()	0	44	9
D	renderSingle()	0	34	10
A	getNumberOfCitedItems()	0	4	1
A	wrapBibEntry()	0	4	1
A	htmlentities()	0	5	1
A	renderCitations()	0	9	2
A	filterCitationItems()	0	15	3
A	isGroupedCitations()	0	8	2
A	renderGroupedCitations()	0	13	3

<?php
/*
 * citeproc-php
 *
 * @link        http://github.com/seboettg/citeproc-php for the source repository
 * @copyright   Copyright (c) 2016 Sebastian Böttger.
 * @license     https://opensource.org/licenses/MIT
 */

namespace Seboettg\CiteProc\Rendering;

use Seboettg\CiteProc\CiteProc;
use Seboettg\CiteProc\Context;
use Seboettg\CiteProc\Data\DataList;
use Seboettg\CiteProc\Styles\AffixesTrait;
use Seboettg\CiteProc\Styles\ConsecutivePunctuationCharacterTrait;
use Seboettg\CiteProc\Styles\FormattingTrait;
use Seboettg\CiteProc\Styles\DelimiterTrait;
use Seboettg\CiteProc\Util\Factory;
use Seboettg\CiteProc\Util\StringHelper;
use Seboettg\Collection\ArrayList;


/**
 * Class Layout
 * @package Seboettg\CiteProc\Rendering
 *
 * @author Sebastian Böttger <seboettg@gmail.com>
 */
class Layout implements Rendering
{

    private static $numberOfCitedItems = 0;

    use AffixesTrait,
        FormattingTrait,
        DelimiterTrait,
        ConsecutivePunctuationCharacterTrait;

    /**
     * @var ArrayList
     */
    private $children;

    /**
     * When used within cs:citation, the delimiter attribute may be used to specify a delimiter for cites within a
     * citation.
     * @var string
     */
    private $delimiter = "";


    private $parent;

    /**
     * @param \Seboettg\CiteProc\Style\StyleElement $parent
     */
    public function __construct($node, $parent)

This method seems to be duplicated in your project.

    {
        $this->parent = $parent;
        self::$numberOfCitedItems = 0;
        $this->children = new ArrayList();
        foreach ($node->children() as $child) {
            $this->children->append(Factory::create($child, $this));
        }
        $this->initDelimiterAttributes($node);
        $this->initAffixesAttributes($node);
        $this->initFormattingAttributes($node);
    }

    /**
     * @param array|DataList $data
     * @param array|ArrayList $citationItems
     * @return string|array
     */
    public function render($data, $citationItems = [])
    {
        $ret = "";
        $sorting = CiteProc::getContext()->getSorting();
        if (!empty($sorting)) {
            CiteProc::getContext()->setRenderingState("sorting");
            $sorting->sort($data);
            CiteProc::getContext()->setRenderingState("rendering");
        }

        if (CiteProc::getContext()->isModeBibliography()) {
            if ($data instanceof DataList) {
                foreach ($data as $citationNumber => $item) {
                    ++self::$numberOfCitedItems;
                    CiteProc::getContext()->getResults()->append($this->wrapBibEntry($this->renderSingle($item, $citationNumber)));
                }
                $ret .= implode($this->delimiter, CiteProc::getContext()->getResults()->toArray());
            } else {
                $ret .= $this->wrapBibEntry($this->renderSingle($data, null));
            }
            $ret = StringHelper::clearApostrophes($ret);
            return "<div class=\"csl-bib-body\">" . $ret . "\n</div>";

        } else if (CiteProc::getContext()->isModeCitation()) {
            if ($data instanceof DataList) {
                if ($citationItems->count() > 0) { //is there a filter for specific citations?

It seems like $citationItems is not always an object, but can also be of type array. Maybe add an additional type check?

                    if ($this->isGroupedCitations($citationItems)) { //if citation items grouped?

It seems like $citationItems defined by parameter $citationItems on line 76 can also be of type array; however, Seboettg\CiteProc\Rendering\Layout::isGroupedCitations() does only seem to accept object<Seboettg\Collection\ArrayList>, maybe add an additional type check?

                        return $this->renderGroupedCitations($data, $citationItems);

It seems like $citationItems defined by parameter $citationItems on line 76 can also be of type array; however, Seboettg\CiteProc\Rendering\Layout::renderGroupedCitations() does only seem to accept object<Seboettg\Collection\ArrayList>, maybe add an additional type check?

                    } else {
                        $data = $this->filterCitationItems($data, $citationItems);

It seems like $citationItems defined by parameter $citationItems on line 76 can also be of type array; however, Seboettg\CiteProc\Rendering\Layout::filterCitationItems() does only seem to accept object<Seboettg\Collection\ArrayList>, maybe add an additional type check?

                        $ret = $this->renderCitations($data, $ret);
                    }

                } else {
                    $ret = $this->renderCitations($data, $ret);
                }

            } else {
                $ret .= $this->renderSingle($data, null);
            }
        }
        $ret = StringHelper::clearApostrophes($ret);
        return $this->addAffixes($ret);
    }

    /**
     * @param $data
     * @param int|null $citationNumber
     * @return string
     */
    private function renderSingle($data, $citationNumber = null)
    {

        $bibliographyOptions = CiteProc::getContext()->getBibliographySpecificOptions();
        $inMargin = [];
        $margin = [];
        foreach ($this->children as $key => $child) {
            $rendered = $child->render($data, $citationNumber);
            $this->getChildsAffixesAndDelimiter($child);
            if (CiteProc::getContext()->isModeBibliography() && $bibliographyOptions->getSecondFieldAlign() === "flush") {

                if ($key === 0 && !empty($rendered)) {
                    $inMargin[] = $rendered;
                } else {
                    $margin[] = $rendered;
                }
            } else {
                $inMargin[] = $rendered;
            }
        }


        if (!empty($inMargin) && !empty($margin) && CiteProc::getContext()->isModeBibliography()) {
            $leftMargin = $this->removeConsecutiveChars($this->htmlentities($this->format(implode("", $inMargin))));
            $rightInline = $this->removeConsecutiveChars($this->htmlentities($this->format(implode("", $margin))) . $this->suffix);
            $res  = '<div class="csl-left-margin">' . $leftMargin . '</div>';
            $res .= '<div class="csl-right-inline">' . $rightInline . '</div>';
            return $res;
        } else if (!empty($inMargin)) {
            $res = $this->format(implode("", $inMargin));
            return $this->htmlentities($this->removeConsecutiveChars($res));
        }
        return "";
    }

    /**
     * @return int
     */
    public static function getNumberOfCitedItems()
    {
        return self::$numberOfCitedItems;
    }

    /**
     * @param string $value
     * @return string
     */
    private function wrapBibEntry($value)
    {
        return "\n  <div class=\"csl-entry\">" . $this->addAffixes($value) . "</div>";
    }

    /**
     * @param string $text
     * @return string
     */
    private function htmlentities($text)
    {
        $text = preg_replace("/(.*)&([^#38;|amp;].*)/u", "$1&#38;$2", $text);
        return $text;
    }

    /**
     * @param $data
     * @param $ret
     * @return string
     */
    private function renderCitations($data, $ret)
    {
        CiteProc::getContext()->getResults()->replace([]);
        foreach ($data as $citationNumber => $item) {
            CiteProc::getContext()->getResults()->append($this->renderSingle($item, $citationNumber));
        }
        $ret .= implode($this->delimiter, CiteProc::getContext()->getResults()->toArray());
        return $ret;
    }

    /**
     * @param DataList $data
     * @param ArrayList $citationItems
     * @return mixed
     */
    private function filterCitationItems($data, $citationItems)
    {
        $arr = $data->toArray();

        $arr_ = array_filter($arr, function($dataItem) use ($citationItems) {
            foreach ($citationItems as $citationItem) {
                if ($dataItem->id === $citationItem->id) {
                    return true;
                }
            }
            return false;
        });

        return $data->replace($arr_);
    }

    /**
     * @param ArrayList $citationItems
     * @return bool
     */
    private function isGroupedCitations(ArrayList $citationItems)
    {
        $firstItem = array_values($citationItems->toArray())[0];
        if (is_array($firstItem)) {
            return true;
        }
        return false;
    }

    /**
     * @param DataList $data
     * @param ArrayList $citationItems
     * @return array|string
     */
    private function renderGroupedCitations($data, $citationItems)
    {
        $group = [];
        foreach ($citationItems as $citationItemGroup) {
            $data_ = $this->filterCitationItems(clone $data, $citationItemGroup);
            CiteProc::getContext()->setCitationItems($data_);

$data_ of type object<Seboettg\Collection\ArrayList> is not a sub-type of object<Seboettg\CiteProc\Data\DataList>. It seems like you assume a child class of the class Seboettg\Collection\ArrayList to be always present.

            $group[] = $this->addAffixes(StringHelper::clearApostrophes($this->renderCitations($data_, "")));
        }
        if (CiteProc::getContext()->isCitationsAsArray()) {
            return $group;
        }
        return implode("\n", $group);
    }

}