Name::formatName() - Code Metrics - Inspection of "bugfixes and cleanup tests" - seboettg/citeproc-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e13826...b82956 )

by Sebastian

created 2016-11-03 17:09 UTC

Name::formatName() B

↳ Parent: Name

Complexity

Conditions	6
Paths	8

Size

Total Lines	28
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	16
nc	8
nop	2
dl	0
loc	28
rs	8.439
c	0
b	0
f	0

<?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\Styles\AffixesTrait;
use Seboettg\CiteProc\Styles\DelimiterTrait;
use Seboettg\CiteProc\Styles\FormattingTrait;
use Seboettg\CiteProc\Util\Factory;
use Seboettg\CiteProc\Util\StringHelper;


/**
 * Class Name
 *
 * The cs:name element, an optional child element of cs:names, can be used to describe the formatting of individual
 * names, and the separation of names within a name variable.
 *
 * @package Seboettg\CiteProc\Rendering\Name
 *
 * @author Sebastian Böttger <[email protected]>
 */
class Name
{
    use FormattingTrait,
        AffixesTrait,
        DelimiterTrait;

    /**
     * @var array
     */
    protected $nameParts;

    /**
     * Specifies the delimiter between the second to last and last name of the names in a name variable. Allowed values
     * are “text” (selects the “and” term, e.g. “Doe, Johnson and Smith”) and “symbol” (selects the ampersand,
     * e.g. “Doe, Johnson & Smith”).
     *
     * @var string
     */
    private $and;

    /**
     * Determines when the name delimiter or a space is used between a truncated name list and the “et-al”
     * (or “and others”) term in case of et-al abbreviation. Allowed values:
     * - “contextual” - (default), name delimiter is only used for name lists truncated to two or more names
     *   - 1 name: “J. Doe et al.”
     *   - 2 names: “J. Doe, S. Smith, et al.”
     * - “after-inverted-name” - name delimiter is only used if the preceding name is inverted as a result of the
     *   - name-as-sort-order attribute. E.g. with name-as-sort-order set to “first”:
     *   - “Doe, J., et al.”
     *   - “Doe, J., S. Smith et al.”
     * - “always” - name delimiter is always used
     *   - 1 name: “J. Doe, et al.”
     *   - 2 names: “J. Doe, S. Smith, et al.”
     * - “never” - name delimiter is never used
     *   - 1 name: “J. Doe et al.”
     *   - 2 names: “J. Doe, S. Smith et al.”
     *
     * @var string
     */
    private $delimiterPrecedesEtAl;

    /**
     * Determines when the name delimiter is used to separate the second to last and the last name in name lists (if
     * and is not set, the name delimiter is always used, regardless of the value of delimiter-precedes-last). Allowed
     * values:
     *
     * - “contextual” - (default), name delimiter is only used for name lists with three or more names
     *   - 2 names: “J. Doe and T. Williams”
     *   - 3 names: “J. Doe, S. Smith, and T. Williams”
     * - “after-inverted-name” - name delimiter is only used if the preceding name is inverted as a result of the
     *   name-as-sort-order attribute. E.g. with name-as-sort-order set to “first”:
     *   - “Doe, J., and T. Williams”
     *   - “Doe, J., S. Smith and T. Williams”
     * - “always” - name delimiter is always used
     *   - 2 names: “J. Doe, and T. Williams”
     *   - 3 names: “J. Doe, S. Smith, and T. Williams”
     * - “never” - name delimiter is never used
     *   - 2 names: “J. Doe and T. Williams”
     *   - 3 names: “J. Doe, S. Smith and T. Williams”
     *
     * @var string
     */
    private $delimiterPrecedesLast;

    /**
     * Use of etAlMin (et-al-min attribute) and etAlUseFirst (et-al-use-first attribute) enables et-al abbreviation. If
     * the number of names in a name variable matches or exceeds the number set on etAlMin, the rendered name list is
     * truncated after reaching the number of names set on etAlUseFirst.
     *
     * @var int
     */
    private $etAlMin;

    /**
     * Use of etAlMin (et-al-min attribute) and etAlUseFirst (et-al-use-first attribute) enables et-al abbreviation. If
     * the number of names in a name variable matches or exceeds the number set on etAlMin, the rendered name list is
     * truncated after reaching the number of names set on etAlUseFirst.
     *
     * @var int
     */
    private $etAlUseFirst;

    /**
     * If used, the values of these attributes (et-al-subsequent-min and et-al-subsequent-use-first) replace those of
     * respectively et-al-min and et-al-use-first for subsequent cites (cites referencing earlier cited items).
     *
     * @var int
     */
    private $etAlSubsequentMin;

    /**
     * If used, the values of these attributes (et-al-subsequent-min and et-al-subsequent-use-first) replace those of
     * respectively et-al-min and et-al-use-first for subsequent cites (cites referencing earlier cited items).
     *
     * @var int
     */
    private $etAlSubsequentUseFirst;

    /**
     * When set to “true” (the default is “false”), name lists truncated by et-al abbreviation are followed by the name
     * delimiter, the ellipsis character, and the last name of the original name list. This is only possible when the
     * original name list has at least two more names than the truncated name list (for this the value of
     * et-al-use-first/et-al-subsequent-min must be at least 2 less than the value of
     * et-al-min/et-al-subsequent-use-first).
     * A. Goffeau, B. G. Barrell, H. Bussey, R. W. Davis, B. Dujon, H. Feldmann, … S. G. Oliver
     *
     * @var bool
     */
    private $etAlUseLast = false;

    /**
     * Specifies whether all the name-parts of personal names should be displayed (value “long”, the default), or only
     * the family name and the non-dropping-particle (value “short”). A third value, “count”, returns the total number
     * of names that would otherwise be rendered by the use of the cs:names element (taking into account the effects of
     * et-al abbreviation and editor/translator collapsing), which allows for advanced sorting.
     *
     * @var string
     */
    private $form = "long";

    /**
     * When set to “false” (the default is “true”), given names are no longer initialized when “initialize-with” is set.
     * However, the value of “initialize-with” is still added after initials present in the full name (e.g. with
     * initialize set to “false”, and initialize-with set to ”.”, “James T Kirk” becomes “James T. Kirk”).
     *
     * @var bool
     */
    private $initialize = true;

    /**
     * When set, given names are converted to initials. The attribute value is added after each initial (”.” results
     * in “J.J. Doe”). For compound given names (e.g. “Jean-Luc”), hyphenation of the initials can be controlled with
     * the global initialize-with-hyphen option
     *
     * @var string
     */
    private $initializeWith = "";

    /**
     * Specifies that names should be displayed with the given name following the family name (e.g. “John Doe” becomes
     * “Doe, John”). The attribute has two possible values:
     *   - “first” - attribute only has an effect on the first name of each name variable
     *   - “all” - attribute has an effect on all names
     * Note that even when name-as-sort-order changes the name-part order, the display order is not necessarily the same
     * as the sorting order for names containing particles and suffixes (see Name-part order). Also, name-as-sort-order
     * only affects names written in the latin or Cyrillic alphabets. Names written in other alphabets (e.g. Asian
     * scripts) are always displayed with the family name preceding the given name.
     *
     * @var string
     */
    private $nameAsSortOrder = "";

    /**
     * Sets the delimiter for name-parts that have switched positions as a result of name-as-sort-order. The default
     * value is ”, ” (“Doe, John”). As is the case for name-as-sort-order, this attribute only affects names written in
     * the latin or Cyrillic alphabets.
     *
     * @var string
     */
    private $sortSeparator = ", ";

    /**
     * Specifies the text string used to separate names in a name variable. Default is ”, ” (e.g. “Doe, Smith”).
     * @var
     */
    private $delimiter = ", ";


    /**
     * @var Names
     */
    private $parent;

    /**
     * Name constructor.
     * @param \SimpleXMLElement $node
     * @param Names $parent
     */
    public function __construct(\SimpleXMLElement $node, Names $parent)
    {
        $this->nameParts = [];
        $this->parent = $parent;

        /** @var \SimpleXMLElement $child */
        foreach ($node->children() as $child) {

            switch ($child->getName()) {
                case "name-part":
                    /** @var NamePart $namePart */
                    $namePart = Factory::create($child, $this);
                    $this->nameParts[$namePart->getName()] = $namePart;
            }
        }


        /** @var \SimpleXMLElement $attribute */
        foreach ($node->attributes() as $attribute) {
            switch ($attribute->getName()) {
                case 'and':
                    $and = (string)$attribute;
                    if ("text" === $and) {
                        $this->and = CiteProc::getContext()->getLocale()->filter('terms', 'and')->single;
                    } elseif ('symbol' === $and) {
                        $this->and = '&';
                    }
                    break;
                case 'delimiter-precedes-et-al':
                    $this->delimiterPrecedesEtAl = (string) $attribute;
                    break;
                case 'delimiter-precedes-last':
                    $this->delimiterPrecedesLast = (string) $attribute;
                    break;
                case 'et-al-min':
                    $this->etAlMin = intval((string) $attribute);
                    break;
                case 'et-al-use-first':
                    $this->etAlUseFirst = intval((string) $attribute);
                    break;
                case 'et-al-subsequent-min':
                    $this->etAlSubsequentMin = intval((string) $attribute);
                    break;
                case 'et-al-subsequent-use-first':
                    $this->etAlSubsequentUseFirst = intval((string) $attribute);
                    break;
                case 'et-al-use-last':
                    $this->etAlUseLast = boolval((string) $attribute);
                    break;
                case 'form':
                    $this->form = (string) $attribute;
                    break;
                case 'initialize':
                    $this->initialize = boolval((string) $attribute);
                    break;
                case 'initialize-with':
                    $this->initializeWith = (string) $attribute;
                    break;
                case 'name-as-sort-order':
                    $this->nameAsSortOrder = (string) $attribute;
                    break;
                case 'sort-separator':
                    $this->sortSeparator = (string) $attribute;

            }
        }

        $this->initFormattingAttributes($node);
        $this->initAffixesAttributes($node);
        $this->initDelimiterAttributes($node);
    }

    public function render($data)
    {
        $resultNames = [];
        $etAl = false;
        $count = 0;
        /**
         * @var string $type
         * @var array $name
         */
        foreach ($data as $rank => $name) {
            ++$count;
            $resultNames[] = $this->formatName($name, $rank);
        }

        /* Use of et-al-min and et-al-user-first enables et-al abbreviation. If the number of names in a name variable
        matches or exceeds the number set on et-al-min, the rendered name list is truncated after reaching the number of
        names set on et-al-use-first.  */
        if (isset($this->etAlMin) && isset($this->etAlUseFirst)) {
            $cnt = count($resultNames);
            if ($this->etAlMin >= count($cnt)) {
                for ($i = $this->etAlUseFirst; $i < $cnt; ++$i) {
                    unset($resultNames[$i]);
                }
            }
            if ($this->parent->hasEtAl()) {
                $etAl = $this->parent->getEtAl()->render($name);
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
            } else {
                $etAl = CiteProc::getContext()->getLocale()->filter('terms', 'et-al')->single;
            }
        }


        /* add "and" */
        $count = count($resultNames);
        if (!empty($this->and) && $count > 1 && !$etAl) {
            $new = $this->and . ' ' . end($resultNames); //stick an "and" in front of the last author if "and" is defined
            $resultNames[key($resultNames)] = $new;
        }

        $text = implode($this->delimiter, $resultNames);

        if (!empty($resultNames) && $etAl) {

            /* By default, when a name list is truncated to a single name, the name and the “et-al” (or “and others”)
            term are separated by a space (e.g. “Doe et al.”). When a name list is truncated to two or more names, the
            name delimiter is used (e.g. “Doe, Smith, et al.”). This behavior can be changed with the
            delimiter-precedes-et-al attribute. */
            switch ($this->delimiterPrecedesEtAl) {
                case 'never':
                    $text = $text . " $etAl";
                    break;
                case 'always':
                    $text = $text . "$this->delimiter$etAl";
                    break;
                default:
                    if (count($resultNames) === 1) {
                        $text .= " $etAl";
                    } else {
                        $text .=  $this->delimiter . $etAl;
                    }

            }
        }
        if ($this->form == 'count') {
            if ($etAl === false) {
                return (int)count($resultNames);
            } else {
                return (int)(count($resultNames) - 1);
            }
        }
        // strip out the last delimiter if not required
        if (isset($this->and) && count($resultNames) > 1) {
            $lastDelimiter = strrpos($text, $this->delimiter . $this->and);
            switch ($this->delimiterPrecedesLast) {
                case 'always':
                    return $text;
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                case 'never':
                    return substr_replace($text, ' ', $lastDelimiter, strlen($this->delimiter));
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                case 'contextual':
                default:
                    if (count($resultNames) < 3 && $lastDelimiter !== false) {
                        return substr_replace($text, ' ', $lastDelimiter, strlen($this->delimiter));
                    }
            }
        }
        return $text;
    }

    private function formatName($name, $rank)
    {
        $useInitials = $this->initialize && !empty($this->initializeWith);
        if ($useInitials) {
            //TODO: initialize with hyphen
            $given = $name->given;
            $name->given = "";
            $givenParts = StringHelper::explodeBySpaceOrHyphen($given);
            foreach ($givenParts as $givenPart) {
                $name->given .= substr($givenPart, 0, 1) . $this->initializeWith;
            }
        }

        // format name-parts
        if (count($this->nameParts) > 0) {
            /** @var NamePart $namePart */
            foreach ($this->nameParts as $namePart) {
                $name->{$namePart->getName()} =   $namePart->render($name);
            }
            $name->suffix = '';
            $name->{'non-dropping-particle'} = '';
            $name->{'dropping-particle'} = '';
        }

        $return = $this->getNamesString($name, $rank);

        return trim($return);
    }

    /**
     * @param $name
     * @return string
     */
    private function getNamesString($name, $rank)
    {
        $text = "";
        $nonDroppingParticle = isset($name->{'non-dropping-particle'}) ? $name->{'non-dropping-particle'} : "";
        $droppingParticle = isset($name->{'dropping-particle'}) ? $name->{'dropping-particle'} : "";
        $suffix = (isset($name->{'suffix'})) ? ' ' . $name->{'suffix'} : '';
        if (!empty($name->given)) {
            $name->given = $this->format(trim($name->given));
        }
        if (isset($name->family)) {
            $name->family = $this->format($name->family);
            if ($this->form == 'short') {
                $text = (!empty($nonDroppingParticle) ? $nonDroppingParticle . " " : "") . $name->family;
            } else {
                switch ($this->nameAsSortOrder) {
                    /*

                        use form "[non-dropping particel] family name,
                        given name [dropping particle], [suffix]"
                     */
                    case 'all':
                    case 'first':
                        if ($this->nameAsSortOrder === "first" && $rank !== 0) {
                            break;
                        }
                        $text =
                            (!empty($nonDroppingParticle) ? $nonDroppingParticle . " " : "") .
                            (trim($name->family) . $this->sortSeparator . trim($name->given)) .
                            (!empty($droppingParticle) ? " " . $droppingParticle : "") .
                            (!empty($suffix) ? $this->sortSeparator . trim($suffix) : "");
                        break;
                    /*

                       use form "given name [dropping particles] [non-dropping particles] family name [suffix]"
                       e.g. [Jean] [de] [La] [Fontaine] [III]
                    */
                    default:
                        $text = trim($name->given) .
                            (!empty($droppingParticle) ? " " . trim($droppingParticle) : "") .
                            (!empty($nonDroppingParticle) ? " " . trim($nonDroppingParticle) : "") .
                            (" " . $name->family) .
                            (!empty($suffix) ? " " . trim($suffix) : "");
                }
            }
        }

        return $text;
    }

    public function getOptions()
    {
        $ignore = ["namePart", "parent", "substitute"];
        $options = [];
        $reflectedName = new \ReflectionClass($this);

        foreach ($reflectedName->getProperties() as $property) {
            $property->setAccessible(true);
            if (in_array($property->getName(), $ignore)) {
                continue;
            } else if ($property->getName() == "and" && $property->getValue($this) === "&") {
                $options["and"] = "symbol";
            } else {
                $propValue = $property->getValue($this);
                if (isset($propValue) && !empty($propValue)) {
                    $options[StringHelper::camelCase2Hyphen($property->getName())] = $propValue;
                }
            }
        }
        return $options;
    }

}

1			<?php
2			/**
3			* citeproc-php
4			*
5			* @link http://github.com/seboettg/citeproc-php for the source repository
6			* @copyright Copyright (c) 2016 Sebastian Böttger.
7			* @license https://opensource.org/licenses/MIT
8			*/
9
10			namespace Seboettg\CiteProc\Rendering\Name;
11			use Seboettg\CiteProc\CiteProc;
12			use Seboettg\CiteProc\Styles\AffixesTrait;
13			use Seboettg\CiteProc\Styles\DelimiterTrait;
14			use Seboettg\CiteProc\Styles\FormattingTrait;
15			use Seboettg\CiteProc\Util\Factory;
16			use Seboettg\CiteProc\Util\StringHelper;
17
18
19			/**
20			* Class Name
21			*
22			* The cs:name element, an optional child element of cs:names, can be used to describe the formatting of individual
23			* names, and the separation of names within a name variable.
24			*
25			* @package Seboettg\CiteProc\Rendering\Name
26			*
27			* @author Sebastian Böttger <[email protected]>
28			*/
29			class Name
30			{
31			use FormattingTrait,
32			AffixesTrait,
33			DelimiterTrait;
34
35			/**
36			* @var array
37			*/
38			protected $nameParts;
39
40			/**
41			* Specifies the delimiter between the second to last and last name of the names in a name variable. Allowed values
42			* are “text” (selects the “and” term, e.g. “Doe, Johnson and Smith”) and “symbol” (selects the ampersand,
43			* e.g. “Doe, Johnson & Smith”).
44			*
45			* @var string
46			*/
47			private $and;
48
49			/**
50			* Determines when the name delimiter or a space is used between a truncated name list and the “et-al”
51			* (or “and others”) term in case of et-al abbreviation. Allowed values:
52			* - “contextual” - (default), name delimiter is only used for name lists truncated to two or more names
53			* - 1 name: “J. Doe et al.”
54			* - 2 names: “J. Doe, S. Smith, et al.”
55			* - “after-inverted-name” - name delimiter is only used if the preceding name is inverted as a result of the
56			* - name-as-sort-order attribute. E.g. with name-as-sort-order set to “first”:
57			* - “Doe, J., et al.”
58			* - “Doe, J., S. Smith et al.”
59			* - “always” - name delimiter is always used
60			* - 1 name: “J. Doe, et al.”
61			* - 2 names: “J. Doe, S. Smith, et al.”
62			* - “never” - name delimiter is never used
63			* - 1 name: “J. Doe et al.”
64			* - 2 names: “J. Doe, S. Smith et al.”
65			*
66			* @var string
67			*/
68			private $delimiterPrecedesEtAl;
69
70			/**
71			* Determines when the name delimiter is used to separate the second to last and the last name in name lists (if
72			* and is not set, the name delimiter is always used, regardless of the value of delimiter-precedes-last). Allowed
73			* values:
74			*
75			* - “contextual” - (default), name delimiter is only used for name lists with three or more names
76			* - 2 names: “J. Doe and T. Williams”
77			* - 3 names: “J. Doe, S. Smith, and T. Williams”
78			* - “after-inverted-name” - name delimiter is only used if the preceding name is inverted as a result of the
79			* name-as-sort-order attribute. E.g. with name-as-sort-order set to “first”:
80			* - “Doe, J., and T. Williams”
81			* - “Doe, J., S. Smith and T. Williams”
82			* - “always” - name delimiter is always used
83			* - 2 names: “J. Doe, and T. Williams”
84			* - 3 names: “J. Doe, S. Smith, and T. Williams”
85			* - “never” - name delimiter is never used
86			* - 2 names: “J. Doe and T. Williams”
87			* - 3 names: “J. Doe, S. Smith and T. Williams”
88			*
89			* @var string
90			*/
91			private $delimiterPrecedesLast;
92
93			/**
94			* Use of etAlMin (et-al-min attribute) and etAlUseFirst (et-al-use-first attribute) enables et-al abbreviation. If
95			* the number of names in a name variable matches or exceeds the number set on etAlMin, the rendered name list is
96			* truncated after reaching the number of names set on etAlUseFirst.
97			*
98			* @var int
99			*/
100			private $etAlMin;
101
102			/**
103			* Use of etAlMin (et-al-min attribute) and etAlUseFirst (et-al-use-first attribute) enables et-al abbreviation. If
104			* the number of names in a name variable matches or exceeds the number set on etAlMin, the rendered name list is
105			* truncated after reaching the number of names set on etAlUseFirst.
106			*
107			* @var int
108			*/
109			private $etAlUseFirst;
110
111			/**
112			* If used, the values of these attributes (et-al-subsequent-min and et-al-subsequent-use-first) replace those of
113			* respectively et-al-min and et-al-use-first for subsequent cites (cites referencing earlier cited items).
114			*
115			* @var int
116			*/
117			private $etAlSubsequentMin;
118
119			/**
120			* If used, the values of these attributes (et-al-subsequent-min and et-al-subsequent-use-first) replace those of
121			* respectively et-al-min and et-al-use-first for subsequent cites (cites referencing earlier cited items).
122			*
123			* @var int
124			*/
125			private $etAlSubsequentUseFirst;
126
127			/**
128			* When set to “true” (the default is “false”), name lists truncated by et-al abbreviation are followed by the name
129			* delimiter, the ellipsis character, and the last name of the original name list. This is only possible when the
130			* original name list has at least two more names than the truncated name list (for this the value of
131			* et-al-use-first/et-al-subsequent-min must be at least 2 less than the value of
132			* et-al-min/et-al-subsequent-use-first).
133			* A. Goffeau, B. G. Barrell, H. Bussey, R. W. Davis, B. Dujon, H. Feldmann, … S. G. Oliver
134			*
135			* @var bool
136			*/
137			private $etAlUseLast = false;
138
139			/**
140			* Specifies whether all the name-parts of personal names should be displayed (value “long”, the default), or only
141			* the family name and the non-dropping-particle (value “short”). A third value, “count”, returns the total number
142			* of names that would otherwise be rendered by the use of the cs:names element (taking into account the effects of
143			* et-al abbreviation and editor/translator collapsing), which allows for advanced sorting.
144			*
145			* @var string
146			*/
147			private $form = "long";
148
149			/**
150			* When set to “false” (the default is “true”), given names are no longer initialized when “initialize-with” is set.
151			* However, the value of “initialize-with” is still added after initials present in the full name (e.g. with
152			* initialize set to “false”, and initialize-with set to ”.”, “James T Kirk” becomes “James T. Kirk”).
153			*
154			* @var bool
155			*/
156			private $initialize = true;
157
158			/**
159			* When set, given names are converted to initials. The attribute value is added after each initial (”.” results
160			* in “J.J. Doe”). For compound given names (e.g. “Jean-Luc”), hyphenation of the initials can be controlled with
161			* the global initialize-with-hyphen option
162			*
163			* @var string
164			*/
165			private $initializeWith = "";
166
167			/**
168			* Specifies that names should be displayed with the given name following the family name (e.g. “John Doe” becomes
169			* “Doe, John”). The attribute has two possible values:
170			* - “first” - attribute only has an effect on the first name of each name variable
171			* - “all” - attribute has an effect on all names
172			* Note that even when name-as-sort-order changes the name-part order, the display order is not necessarily the same
173			* as the sorting order for names containing particles and suffixes (see Name-part order). Also, name-as-sort-order
174			* only affects names written in the latin or Cyrillic alphabets. Names written in other alphabets (e.g. Asian
175			* scripts) are always displayed with the family name preceding the given name.
176			*
177			* @var string
178			*/
179			private $nameAsSortOrder = "";
180
181			/**
182			* Sets the delimiter for name-parts that have switched positions as a result of name-as-sort-order. The default
183			* value is ”, ” (“Doe, John”). As is the case for name-as-sort-order, this attribute only affects names written in
184			* the latin or Cyrillic alphabets.
185			*
186			* @var string
187			*/
188			private $sortSeparator = ", ";
189
190			/**
191			* Specifies the text string used to separate names in a name variable. Default is ”, ” (e.g. “Doe, Smith”).
192			* @var
193			*/
194			private $delimiter = ", ";
195
196
197			/**
198			* @var Names
199			*/
200			private $parent;
201
202			/**
203			* Name constructor.
204			* @param \SimpleXMLElement $node
205			* @param Names $parent
206			*/
207			public function __construct(\SimpleXMLElement $node, Names $parent)
208			{
209			$this->nameParts = [];
210			$this->parent = $parent;
211
212			/** @var \SimpleXMLElement $child */
213			foreach ($node->children() as $child) {
214
215			switch ($child->getName()) {
216			case "name-part":
217			/** @var NamePart $namePart */
218			$namePart = Factory::create($child, $this);
219			$this->nameParts[$namePart->getName()] = $namePart;
220			}
221			}
222
223
224			/** @var \SimpleXMLElement $attribute */
225			foreach ($node->attributes() as $attribute) {
226			switch ($attribute->getName()) {
227			case 'and':
228			$and = (string)$attribute;
229			if ("text" === $and) {
230			$this->and = CiteProc::getContext()->getLocale()->filter('terms', 'and')->single;
231			} elseif ('symbol' === $and) {
232			$this->and = '&';
233			}
234			break;
235			case 'delimiter-precedes-et-al':
236			$this->delimiterPrecedesEtAl = (string) $attribute;
237			break;
238			case 'delimiter-precedes-last':
239			$this->delimiterPrecedesLast = (string) $attribute;
240			break;
241			case 'et-al-min':
242			$this->etAlMin = intval((string) $attribute);
243			break;
244			case 'et-al-use-first':
245			$this->etAlUseFirst = intval((string) $attribute);
246			break;
247			case 'et-al-subsequent-min':
248			$this->etAlSubsequentMin = intval((string) $attribute);
249			break;
250			case 'et-al-subsequent-use-first':
251			$this->etAlSubsequentUseFirst = intval((string) $attribute);
252			break;
253			case 'et-al-use-last':
254			$this->etAlUseLast = boolval((string) $attribute);
255			break;
256			case 'form':
257			$this->form = (string) $attribute;
258			break;
259			case 'initialize':
260			$this->initialize = boolval((string) $attribute);
261			break;
262			case 'initialize-with':
263			$this->initializeWith = (string) $attribute;
264			break;
265			case 'name-as-sort-order':
266			$this->nameAsSortOrder = (string) $attribute;
267			break;
268			case 'sort-separator':
269			$this->sortSeparator = (string) $attribute;
270
271			}
272			}
273
274			$this->initFormattingAttributes($node);
275			$this->initAffixesAttributes($node);
276			$this->initDelimiterAttributes($node);
277			}
278
279			public function render($data)
280			{
281			$resultNames = [];
282			$etAl = false;
283			$count = 0;
284			/**
285			* @var string $type
286			* @var array $name
287			*/
288			foreach ($data as $rank => $name) {
289			++$count;
290			$resultNames[] = $this->formatName($name, $rank);
291			}
292
293			/* Use of et-al-min and et-al-user-first enables et-al abbreviation. If the number of names in a name variable
294			matches or exceeds the number set on et-al-min, the rendered name list is truncated after reaching the number of
295			names set on et-al-use-first. */
296			if (isset($this->etAlMin) && isset($this->etAlUseFirst)) {
297			$cnt = count($resultNames);
298			if ($this->etAlMin >= count($cnt)) {
299			for ($i = $this->etAlUseFirst; $i < $cnt; ++$i) {
300			unset($resultNames[$i]);
301			}
302			}
303			if ($this->parent->hasEtAl()) {
304			$etAl = $this->parent->getEtAl()->render($name);
			0 ignored issues – show Bug introduced 2016-11-03 17:19 UTC by Report Bug Copy Issue Report The variable `$name` seems to be defined by a `foreach` iteration on line `288`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history... Documentation introduced 2016-11-03 17:19 UTC by Report Bug Copy Issue Report `$name` is of type `array`, but the function expects a `object<stdClass>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
305			} else {
306			$etAl = CiteProc::getContext()->getLocale()->filter('terms', 'et-al')->single;
307			}
308			}
309
310
311			/* add "and" */
312			$count = count($resultNames);
313			if (!empty($this->and) && $count > 1 && !$etAl) {
314			$new = $this->and . ' ' . end($resultNames); //stick an "and" in front of the last author if "and" is defined
315			$resultNames[key($resultNames)] = $new;
316			}
317
318			$text = implode($this->delimiter, $resultNames);
319
320			if (!empty($resultNames) && $etAl) {
321
322			/* By default, when a name list is truncated to a single name, the name and the “et-al” (or “and others”)
323			term are separated by a space (e.g. “Doe et al.”). When a name list is truncated to two or more names, the
324			name delimiter is used (e.g. “Doe, Smith, et al.”). This behavior can be changed with the
325			delimiter-precedes-et-al attribute. */
326			switch ($this->delimiterPrecedesEtAl) {
327			case 'never':
328			$text = $text . " $etAl";
329			break;
330			case 'always':
331			$text = $text . "$this->delimiter$etAl";
332			break;
333			default:
334			if (count($resultNames) === 1) {
335			$text .= " $etAl";
336			} else {
337			$text .= $this->delimiter . $etAl;
338			}
339
340			}
341			}
342			if ($this->form == 'count') {
343			if ($etAl === false) {
344			return (int)count($resultNames);
345			} else {
346			return (int)(count($resultNames) - 1);
347			}
348			}
349			// strip out the last delimiter if not required
350			if (isset($this->and) && count($resultNames) > 1) {
351			$lastDelimiter = strrpos($text, $this->delimiter . $this->and);
352			switch ($this->delimiterPrecedesLast) {
353			case 'always':
354			return $text;
355			break;
			0 ignored issues – show Unused Code introduced 2016-11-02 09:51 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
356			case 'never':
357			return substr_replace($text, ' ', $lastDelimiter, strlen($this->delimiter));
358			break;
			0 ignored issues – show Unused Code introduced 2016-11-02 09:51 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
359			case 'contextual':
360			default:
361			if (count($resultNames) < 3 && $lastDelimiter !== false) {
362			return substr_replace($text, ' ', $lastDelimiter, strlen($this->delimiter));
363			}
364			}
365			}
366			return $text;
367			}
368
369			private function formatName($name, $rank)
370			{
371			$useInitials = $this->initialize && !empty($this->initializeWith);
372			if ($useInitials) {
373			//TODO: initialize with hyphen
374			$given = $name->given;
375			$name->given = "";
376			$givenParts = StringHelper::explodeBySpaceOrHyphen($given);
377			foreach ($givenParts as $givenPart) {
378			$name->given .= substr($givenPart, 0, 1) . $this->initializeWith;
379			}
380			}
381
382			// format name-parts
383			if (count($this->nameParts) > 0) {
384			/** @var NamePart $namePart */
385			foreach ($this->nameParts as $namePart) {
386			$name->{$namePart->getName()} = $namePart->render($name);
387			}
388			$name->suffix = '';
389			$name->{'non-dropping-particle'} = '';
390			$name->{'dropping-particle'} = '';
391			}
392
393			$return = $this->getNamesString($name, $rank);
394
395			return trim($return);
396			}
397
398			/**
399			* @param $name
400			* @return string
401			*/
402			private function getNamesString($name, $rank)
403			{
404			$text = "";
405			$nonDroppingParticle = isset($name->{'non-dropping-particle'}) ? $name->{'non-dropping-particle'} : "";
406			$droppingParticle = isset($name->{'dropping-particle'}) ? $name->{'dropping-particle'} : "";
407			$suffix = (isset($name->{'suffix'})) ? ' ' . $name->{'suffix'} : '';
408			if (!empty($name->given)) {
409			$name->given = $this->format(trim($name->given));
410			}
411			if (isset($name->family)) {
412			$name->family = $this->format($name->family);
413			if ($this->form == 'short') {
414			$text = (!empty($nonDroppingParticle) ? $nonDroppingParticle . " " : "") . $name->family;
415			} else {
416			switch ($this->nameAsSortOrder) {
417			/*
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-11-03 09:28 UTC by Report Bug Copy Issue Report `43%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
418			use form "[non-dropping particel] family name,
419			given name [dropping particle], [suffix]"
420			*/
421			case 'all':
422			case 'first':
423			if ($this->nameAsSortOrder === "first" && $rank !== 0) {
424			break;
425			}
426			$text =
427			(!empty($nonDroppingParticle) ? $nonDroppingParticle . " " : "") .
428			(trim($name->family) . $this->sortSeparator . trim($name->given)) .
429			(!empty($droppingParticle) ? " " . $droppingParticle : "") .
430			(!empty($suffix) ? $this->sortSeparator . trim($suffix) : "");
431			break;
432			/*
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-11-03 09:28 UTC by Report Bug Copy Issue Report `39%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
433			use form "given name [dropping particles] [non-dropping particles] family name [suffix]"
434			e.g. [Jean] [de] [La] [Fontaine] [III]
435			*/
436			default:
437			$text = trim($name->given) .
438			(!empty($droppingParticle) ? " " . trim($droppingParticle) : "") .
439			(!empty($nonDroppingParticle) ? " " . trim($nonDroppingParticle) : "") .
440			(" " . $name->family) .
441			(!empty($suffix) ? " " . trim($suffix) : "");
442			}
443			}
444			}
445
446			return $text;
447			}
448
449			public function getOptions()
450			{
451			$ignore = ["namePart", "parent", "substitute"];
452			$options = [];
453			$reflectedName = new \ReflectionClass($this);
454
455			foreach ($reflectedName->getProperties() as $property) {
456			$property->setAccessible(true);
457			if (in_array($property->getName(), $ignore)) {
458			continue;
459			} else if ($property->getName() == "and" && $property->getValue($this) === "&") {
460			$options["and"] = "symbol";
461			} else {
462			$propValue = $property->getValue($this);
463			if (isset($propValue) && !empty($propValue)) {
464			$options[StringHelper::camelCase2Hyphen($property->getName())] = $propValue;
465			}
466			}
467			}
468			return $options;
469			}
470
471			}

seboettg / citeproc-php

Push — master ( e13826...b82956 )

Name::formatName() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like