InheritableNameAttributesTrait.php

<?php
/*
 * citeproc-php
 *
 * @link        http://github.com/seboettg/citeproc-php for the source repository
 * @copyright   Copyright (c) 2017 Sebastian Böttger.
 * @license     https://opensource.org/licenses/MIT
 */
 
namespace Seboettg\CiteProc\Style;
 
use Seboettg\CiteProc\CiteProc;
use Seboettg\CiteProc\Rendering\HasParent;
use Seboettg\CiteProc\Rendering\Name\Name;
use Seboettg\CiteProc\Rendering\Name\Names;
use Seboettg\CiteProc\Root\Root;
use SimpleXMLElement;
 
trait InheritableNameAttributesTrait
{
    public static $attributes = [
        'and',
        'delimiter-precedes-et-al',
        'delimiter-precedes-last',
        'et-al-min',
        'et-al-use-first',
        'et-al-use-last',
        'et-al-subsequent-min',
        'et-al-subsequent-use-first',
        'initialize',
        'initialize-with',
        'name-as-sort-order',
        'sort-separator',
        'name-form',
        'form',
        'name-delimiter',
        'delimiter'
    ];
 
    protected $attributesInitialized = false;
 
    private $and;
 
    private $delimiterPrecedesEtAl;
 
    private $delimiterPrecedesLast;
 
    private $etAlMin;
 
    private $etAlUseFirst;
 
    private $etAlUseLast = false;
 
    private $etAlSubsequentMin;
 
    private $etAlSubsequentUseFirst;
 
    private $initialize = true;
 
    private $initializeWith = false;
 
    private $nameAsSortOrder = "";
 
    private $sortSeparator = ", ";
 
    private $form;
 
    private $nameForm = "long";
 
    private $nameDelimiter = ", ";
 
    public function isDescendantOfMacro()
    {
        $parent = $this->parent;
 
        while ($parent != null && $parent instanceof HasParent) {
            if ($parent instanceof Macro) {
                return true;
            }
            $parent = $parent->getParent();
        }
        return false;
    }
 
    public function initInheritableNameAttributes(SimpleXMLElement $node)
    {
        $context = CiteProc::getContext();
        $parentStyleElement = null;
        if ($this instanceof  Name || $this instanceof Names) {
            if ($context->getMode() === "bibliography") {
                if ($this->isDescendantOfMacro()) {
                    $parentStyleElement = $context->getRoot();
                } else {
                    $parentStyleElement = $context->getBibliography();
                }
            } else {
                $parentStyleElement = $context->getCitation();
            }
        } elseif ($this instanceof StyleElement) {
            $parentStyleElement = $context->getRoot();
        }
 
        foreach (self::$attributes as $nameAttribute) {
            $attribute = $node[$nameAttribute];
            switch ($nameAttribute) {
                case 'and':
                    if (!empty($attribute)) {
                        $this->and = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) { //inherit from parent style
                        $this->and = $parentStyleElement->getAnd();
                    }
                    break;
                case 'delimiter-precedes-et-al':
                    if (!empty($attribute)) {
                        $this->delimiterPrecedesEtAl = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) { //inherit from parent style
                        $this->delimiterPrecedesEtAl = $parentStyleElement->getDelimiterPrecedesEtAl();
                    }
                    break;
                case 'delimiter-precedes-last':
                    if (!empty($attribute)) {
                        $this->delimiterPrecedesLast = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) { //inherit from parent style
                        $this->delimiterPrecedesLast = $parentStyleElement->getDelimiterPrecedesLast();
                    }
                    break;
                case 'et-al-min':
                    if (!empty($attribute)) {
                        $this->etAlMin = intval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->etAlMin = $parentStyleElement->getEtAlMin();
                    }
                    break;
                case 'et-al-use-first':
                    if (!empty($attribute)) {
                        $this->etAlUseFirst = intval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->etAlUseFirst = $parentStyleElement->getEtAlUseFirst();
                    }
                    break;
                case 'et-al-subsequent-min':
                    if (!empty($attribute)) {
                        $this->etAlSubsequentMin = intval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->etAlSubsequentMin = $parentStyleElement->getEtAlSubsequentMin();
                    }
                    break;
                case 'et-al-subsequent-use-first':
                    if (!empty($attribute)) {
                        $this->etAlSubsequentUseFirst = intval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->etAlSubsequentUseFirst = $parentStyleElement->getEtAlSubsequentUseFirst();
                    }
                    break;
                case 'et-al-use-last':
                    if (!empty($attribute)) {
                        $this->etAlUseLast = boolval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->etAlUseLast = $parentStyleElement->getEtAlUseLast();
                    }
                    break;
                case 'initialize':
                    if (!empty($attribute)) {
                        $this->initialize = boolval((string) $attribute);
                    } elseif (!empty($parentStyleElement)) {
                        $this->initialize = $parentStyleElement->getInitialize();
                    }
                    break;
                case 'initialize-with':
                    if (!empty($attribute)) {
                        $this->initializeWith = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) {
                        $this->initializeWith = $parentStyleElement->getInitializeWith();
                    }
                    break;
                case 'name-as-sort-order':
                    if (!empty($attribute)) {
                        $this->nameAsSortOrder = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) {
                        $this->nameAsSortOrder = $parentStyleElement->getNameAsSortOrder();
                    }
                    break;
                case 'sort-separator':
                    if (!empty($attribute)) {
                        $this->sortSeparator = (string) $attribute;
                    } elseif (!empty($parentStyleElement)) {
                        $this->sortSeparator = $parentStyleElement->getSortSeparator();
                    }
                    break;
                case 'name-form':
                    if ($this instanceof Root || $this instanceof StyleElement) {
                        if (!empty($attribute)) {
                            $this->setNameForm((string) $attribute);
                        } elseif (!empty($parentStyleElement)) {
                            $this->setNameForm($parentStyleElement->getNameForm());
                        }
                    }
                    break;
                case 'form':
                    if ($this instanceof Name) {
                        if (!empty($attribute)) {
                            $this->setForm((string) $attribute);
                        } elseif (!empty($parentStyleElement)) {
                            $this->setForm($parentStyleElement->getNameForm());
                        }
                    }
                    break;
                case 'name-delimiter':
                    if ($this instanceof Root || $this instanceof StyleElement) {
                        if (!empty($attribute)) {
                            $this->setNameDelimiter((string) $attribute);
                        } elseif (!empty($parentStyleElement)) {
                            $this->setNameDelimiter($parentStyleElement->getNameDelimiter());
                        }
                    } else {
                        /* The attributes name-form and name-delimiter correspond to the form and delimiter attributes
                           on cs:name. Similarly, names-delimiter corresponds to the delimiter attribute on cs:names. */
                        if (!empty($attribute)) {
                            $this->nameDelimiter = $this->delimiter = (string) $attribute;
                        } elseif (!empty($parentStyleElement)) {
                            $this->nameDelimiter = $this->delimiter = $parentStyleElement->getNameDelimiter();
                        }
                    }
                    break;
                case 'delimiter':
                    if ($this instanceof Name) {
                        if (!empty($attribute)) {
                            $this->setDelimiter((string) $attribute);
                        } elseif (!empty($parentStyleElement)) {
                            $this->setDelimiter($parentStyleElement->getNameDelimiter());
                        }
                    }
            }
        }
        $this->attributesInitialized = true;
    }
 
    public function getAnd()
    {
        return $this->and;
    }
 
    public function setAnd($and)
    {
        $this->and = $and;
    }
 
    public function getDelimiterPrecedesEtAl()
    {
        return $this->delimiterPrecedesEtAl;
    }
 
    public function setDelimiterPrecedesEtAl($delimiterPrecedesEtAl)
    {
        $this->delimiterPrecedesEtAl = $delimiterPrecedesEtAl;
    }
 
    public function getDelimiterPrecedesLast()
    {
        return $this->delimiterPrecedesLast;
    }
 
    public function setDelimiterPrecedesLast($delimiterPrecedesLast)
    {
        $this->delimiterPrecedesLast = $delimiterPrecedesLast;
    }
 
    public function getEtAlMin()
    {
        return $this->etAlMin;
    }
 
    public function setEtAlMin($etAlMin)
    {
        $this->etAlMin = $etAlMin;
    }
 
    public function getEtAlUseFirst()
    {
        return $this->etAlUseFirst;
    }
 
    public function setEtAlUseFirst($etAlUseFirst)
    {
        $this->etAlUseFirst = $etAlUseFirst;
    }
 
    public function getEtAlUseLast()
    {
        return $this->etAlUseLast;
    }
 
    public function setEtAlUseLast($etAlUseLast)
    {
        $this->etAlUseLast = $etAlUseLast;
    }
 
    public function getEtAlSubsequentMin()
    {
        return $this->etAlSubsequentMin;
    }
 
    public function setEtAlSubsequentMin($etAlSubsequentMin)
    {
        $this->etAlSubsequentMin = $etAlSubsequentMin;
    }
 
    public function getEtAlSubsequentUseFirst()
    {
        return $this->etAlSubsequentUseFirst;
    }
 
    public function setEtAlSubsequentUseFirst($etAlSubsequentUseFirst)
    {
        $this->etAlSubsequentUseFirst = $etAlSubsequentUseFirst;
    }
 
    public function getInitialize()
    {
        return $this->initialize;
    }
 
    public function setInitialize($initialize)
    {
        $this->initialize = $initialize;
    }
 
    public function getInitializeWith()
    {
        return $this->initializeWith;
    }
 
    public function setInitializeWith($initializeWith)
    {
        $this->initializeWith = $initializeWith;
    }
 
    public function getNameAsSortOrder()
    {
        return $this->nameAsSortOrder;
    }
 
    public function setNameAsSortOrder($nameAsSortOrder)
    {
        $this->nameAsSortOrder = $nameAsSortOrder;
    }
 
    public function getSortSeparator()
    {
        return $this->sortSeparator;
    }
 
    public function setSortSeparator($sortSeparator)
    {
        $this->sortSeparator = $sortSeparator;
    }
 
    public function getForm()
    {
        return $this->form;
    }
 
    public function setForm($form)
    {
        $this->form = $form;
    }
 
    public function getNameForm()
    {
        return $this->nameForm;
    }
 
    public function setNameForm($nameForm)
    {
        $this->nameForm = $nameForm;
    }
 
    public function getNameDelimiter()
    {
        return $this->nameDelimiter;
    }
 
    public function setNameDelimiter($nameDelimiter)
    {
        $this->nameDelimiter = $nameDelimiter;
    }
}