Names.php

<?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\Name;
 
use Seboettg\CiteProc\CiteProc;
use Seboettg\CiteProc\Exception\CiteProcException;
use Seboettg\CiteProc\Exception\InvalidStylesheetException;
use Seboettg\CiteProc\Rendering\HasParent;
use Seboettg\CiteProc\Rendering\Label;
use Seboettg\CiteProc\Rendering\Rendering;
use Seboettg\CiteProc\RenderingState;
use Seboettg\CiteProc\Style\InheritableNameAttributesTrait;
use Seboettg\CiteProc\Styles\AffixesTrait;
use Seboettg\CiteProc\Styles\DelimiterTrait;
use Seboettg\CiteProc\Styles\FormattingTrait;
use Seboettg\CiteProc\Util\Factory;
use Seboettg\CiteProc\Util\NameHelper;
use Seboettg\Collection\ArrayList;
use SimpleXMLElement;
use stdClass;
 
class Names implements Rendering, HasParent
{
    use DelimiterTrait,
        AffixesTrait,
        FormattingTrait,
        InheritableNameAttributesTrait;
 
    private $variables;
 
    private $name;
 
    private $label;
 
    private $substitute;
 
    private $etAl;
 
    private $delimiter = ", ";
 
    private $parent;
 
    public function __construct(SimpleXMLElement $node, $parent)
    {
        $this->initInheritableNameAttributes($node);
        $this->parent = $parent;
        foreach ($node->children() as $child) {
            switch ($child->getName()) {
                case "name":
                    $this->name = Factory::create($child, $this);
                    break;
                case "label":
                    $this->label = Factory::create($child);
                    break;
                case "substitute":
                    $this->substitute = new Substitute($child, $this);
                    break;
                case "et-al":
                    $this->etAl = Factory::create($child);
            }
        }
 
        foreach ($node->attributes() as $attribute) {
            if ("variable" === $attribute->getName()) {
                $this->variables = new ArrayList(explode(" ", (string) $attribute));
                break;
            }
        }
 
        $this->initDelimiterAttributes($node);
        $this->initAffixesAttributes($node);
        $this->initFormattingAttributes($node);
    }
 
    public function render($data, $citationNumber = null)
    {
        $str = "";
 
        /* when the selection consists of “editor” and “translator”, and when the contents of these two name variables
        is identical, then the contents of only one name variable is rendered. In addition, the “editortranslator”
        term is used if the cs:names element contains a cs:label element, replacing the default “editor” and
        “translator” terms (e.g. resulting in “Doe (editor & translator)”) */
        if ($this->variables->hasValue("editor") && $this->variables->hasValue("translator")) {
            if (isset($data->editor)
                && isset($data->translator) && NameHelper::sameNames($data->editor, $data->translator)
            ) {
                if (isset($this->name)) {
                    $str .= $this->name->render($data, 'editor');
                } else {
                    $arr = [];
                    foreach ($data->editor as $editor) {
                        $edt = $this->format($editor->family.", ".$editor->given);
                        $results[] = NameHelper::addExtendedMarkup('editor', $editor, $edt);
                    }
                    $str .= implode($this->delimiter, $arr);
                }
                if (isset($this->label)) {
                    $this->label->setVariable("editortranslator");
                    $str .= $this->label->render($data);
                }
                $vars = $this->variables->toArray();
                $vars = array_filter($vars, function ($value) {
                    return !($value === "editor" || $value === "translator");
                });
                $this->variables->setArray($vars);
            }
        }
 
        $results = [];
        foreach ($this->variables as $var) {
            if (!empty($data->{$var})) {
                if (!empty($this->name)) {
                    $res = $this->name->render($data, $var, $citationNumber);
                    $name = $res;
                    if (!empty($this->label)) {
                        $name = $this->appendLabel($data, $var, $name);
                    }
                    //add multiple counting values
                    if (is_numeric($name) && $this->name->getForm() === "count") {
                        $results = $this->addCountValues($res, $results);
                    } else {
                        $results[] = $this->format($name);
                    }
                } else {
                    foreach ($data->{$var} as $name) {
                        $formatted = $this->format($name->given." ".$name->family);
                        $results[] = NameHelper::addExtendedMarkup($var, $name, $formatted);
                    }
                }
                // suppress substituted variables
                if (CiteProc::getContext()->getRenderingState()->getValue() === RenderingState::SUBSTITUTION) {
                    unset($data->{$var});
                }
            } else {
                if (!empty($this->substitute)) {
                    $results[] = $this->substitute->render($data);
                }
            }
        }
        $results = $this->filterEmpty($results);
        $str .= implode($this->delimiter, $results);
        return !empty($str) ? $this->addAffixes($str) : "";
    }
 
 
    private function appendLabel($data, $var, $name)
    {
        $this->label->setVariable($var);
        if (in_array($this->label->getForm(), ["verb", "verb-short"])) {
            $name = $this->label->render($data).$name;
        } else {
            $name .= $this->label->render($data);
        }
        return $name;
    }
 
    private function addCountValues($res, $results)
    {
        $lastElement = current($results);
        $key = key($results);
        if (!empty($lastElement)) {
            $lastElement += $res;
            $results[$key] = $lastElement;
        } else {
            $results[] = $res;
        }
        return $results;
    }
 
    public function hasEtAl()
    {
        return !empty($this->etAl);
    }
 
    public function getEtAl()
    {
        return $this->etAl;
    }
 
    public function setEtAl(EtAl $etAl)
    {
        $this->etAl = $etAl;
        return $this;
    }
 
    public function hasName()
    {
        return !empty($this->name);
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function setName(Name $name)
    {
        $this->name = $name;
        return $this;
    }
 
    public function getDelimiter()
    {
        return $this->delimiter;
    }
 
    public function getVariables()
    {
        return $this->variables;
    }
 
    public function hasLabel()
    {
        return !empty($this->label);
    }
 
    public function getLabel()
    {
        return $this->label;
    }
 
    public function setLabel($label)
    {
        $this->label = $label;
    }
 
    public function getParent()
    {
        return $this->parent;
    }
 
    private function filterEmpty(array $results)
    {
        return array_filter($results, function ($item) {
            return !empty($item);
        });
    }
}