ConceptPropertyValue

Complexity

Total Complexity

64

Size/Duplication

Total Lines	240
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	3
A	getLang()	0	3	1
A	__toString()	0	3	2
A	getUri()	0	3	1
A	sortSubMembers()	0	4	2
A	getSortKey()	0	3	1
A	getRdfListItems()	0	3	1
A	isExternal()	0	3	1
A	getExVocab()	0	3	1
A	getVocabName()	0	3	1
A	isRdfListTruncated()	0	3	1
A	getNotation()	0	4	3
A	isReified()	0	3	2
A	addSubMember()	0	5	2
D	getLabel()	0	47	18
A	getType()	0	3	1
A	getSubMembers()	0	7	2
B	getReifiedPropertyValues()	0	18	7
A	isRdfList()	0	3	2
A	getVocab()	0	3	1
B	parseRdfList()	0	33	11

<?php

/**
 * Class for handling concept property values.
 */
class ConceptPropertyValue extends VocabularyDataObject
{
    /** submembers */
    private $submembers;
    /** property type */
    private $type;
    /** content language */
    private $clang;
    /** whether the property value is external w.r.t. to the subject resource */
    private $external;
    /** ordered list items if this value is an RDF list */
    private $listItems;
    /** whether the RDF list was truncated due to max limit */
    private $listTruncated;

    public function __construct($model, $vocab, $resource, $prop, $clang = '')
    {
        parent::__construct($model, $vocab, $resource);
        $this->submembers = array();
        $this->type = $prop;
        $this->clang = $clang;
        $this->listItems = null;
        $this->listTruncated = false;
        // check if the resource is external to the current vocabulary
        $this->external = ($this->getLabel('', 'null', false) === null);
        if ($this->external) {
            // if we find the resource in another vocabulary, use it instead
            $exvocab = $this->getExVocab();
            if ($exvocab !== null) {
                $this->vocab = $exvocab;
            }
        }
        // check if this resource is an RDF list and parse it
        $this->parseRdfList();
    }

    public function __toString()
    {
        return is_string($this->getLabel()) ? $this->getLabel() : $this->getLabel()->getValue();

The condition is_string($this->getLabel()) is always false.

    }

    public function getLang()
    {
        return $this->model->getLocale();
    }

    public function getSortKey()
    {
        return strtolower($this->getLabel());

It seems like $this->getLabel() can also be of type null; however, parameter $string of strtolower() does only seem to accept string, maybe add an additional type check?

    }

    public function getLabel($lang = '', $fallbackToUri = 'uri', $allowExternal = true)
    {
        if ($this->clang) {
            $lang = $this->clang;
        }
        if ($this->vocab->getConfig()->getLanguageOrder($lang)) {
            foreach ($this->vocab->getConfig()->getLanguageOrder($lang) as $fallback) {
                if ($this->resource->label($fallback) !== null) {
                    return $this->resource->label($fallback);
                }
                // We need to check all the labels in case one of them matches a subtag of the current language
                if ($this->resource->allLiterals('skos:prefLabel')) {
                    foreach ($this->resource->allLiterals('skos:prefLabel') as $label) {
                        // the label lang code is a subtag of the UI lang eg. en-GB - create a new literal with the main language
                        if ($label !== null && strpos($label->getLang(), $fallback . '-') === 0) {
                            return EasyRdf\Literal::create($label, $fallback);
                        }
                    }
                }
            }
        }

        if ($this->resource->label($lang) !== null) { // current language
            return $this->resource->label($lang);
        } elseif ($this->resource->label($this->vocab->getConfig()->getDefaultLanguage()) !== null) { // vocab default language
            return $this->resource->label($this->vocab->getConfig()->getDefaultLanguage());
        } elseif ($this->resource->label() !== null) { // any language
            return $this->resource->label();
        } elseif ($this->resource->getLiteral('rdf:value', $lang) !== null) { // current language
            return $this->resource->getLiteral('rdf:value', $lang);
        } elseif ($this->resource->getLiteral('rdf:value') !== null) { // any language
            return $this->resource->getLiteral('rdf:value');
        }

        // see if we can find a label in another vocabulary known by the skosmos instance
        if ($allowExternal) {
            $label = $this->getExternalLabel($this->vocab, $this->getUri(), $lang);
            if ($label) {

$label is of type EasyRdf\Literal, thus it always evaluated to true.

                return $label;
            }
        }

        if ($fallbackToUri == 'uri') {
            // return uri if no label is found
            return $this->resource->shorten() ? $this->resource->shorten() : $this->getUri();
        }
        return null;
    }

    public function getType()
    {
        return $this->type;
    }

    public function getUri()
    {
        return $this->resource->getUri();
    }

    public function getExVocab()
    {
        return $this->model->guessVocabularyFromURI($this->getUri(), $this->vocab->getId());
    }

    public function getVocab()
    {
        return $this->vocab;
    }

    public function getVocabName()
    {
        return $this->vocab->getShortName();
    }

    public function addSubMember($member, $lang = '')
    {
        $label = $member->getLabel($lang) ? $member->getLabel($lang) : $member->getLabel();
        $this->submembers[$label->getValue()] = $member;
        $this->sortSubMembers();
    }

    public function getSubMembers()
    {
        if (empty($this->submembers)) {
            return null;
        }

        return $this->submembers;
    }

    private function sortSubMembers()
    {
        if (!empty($this->submembers)) {
            ksort($this->submembers);
        }

    }

    public function isExternal()
    {
        return $this->external;
    }

    public function getNotation()
    {
        if ($this->vocab->getConfig()->showNotation() && $this->resource->get('skos:notation')) {
            return $this->resource->get('skos:notation')->getValue();
        }

    }

    public function isReified()
    {
        return (!$this->resource->label() && $this->resource->getLiteral('rdf:value'));
    }

    public function getReifiedPropertyValues()
    {
        $ret = array();
        $props = $this->resource->propertyUris();
        foreach ($props as $prop) {
            $prop = (EasyRdf\RdfNamespace::shorten($prop) !== null) ? EasyRdf\RdfNamespace::shorten($prop) : $prop;
            $propkey = str_starts_with($prop, 'dc11:') ?
                str_replace('dc11:', 'dc:', $prop) : $prop;
            foreach ($this->resource->allLiterals($prop) as $val) {
                if ($prop !== 'rdf:value') { // shown elsewhere
                    $ret[$this->model->getText($propkey)] = new ConceptPropertyValueLiteral($this->model, $this->vocab, $this->resource, $val, $prop);
                }
            }
            foreach ($this->resource->allResources($prop) as $val) {
                $ret[$this->model->getText($propkey)] = new ConceptPropertyValue($this->model, $this->vocab, $val, $prop, $this->clang);
            }
        }
        return $ret;
    }

    /**
     * Check if this resource represents an RDF list (has rdf:first property)
     * and parse the list items in order
     */
    private function parseRdfList()
    {
        // Check if this resource has rdf:first (indicating it's a list node)
        if ($this->resource->getResource('rdf:first') === null) {
            return; // Not an RDF list
        }

        $this->listItems = array();
        $currentNode = $this->resource;
        $itemsLimit = $this->model->getConfig()->getRdfListItemsLimit();
        $iteration = 0;

        while ($currentNode !== null && !($itemsLimit > 0 && $iteration >= $itemsLimit)) {
            $item = $currentNode->getResource('rdf:first');
            if ($item !== null) {
                $listItemValue = new ConceptPropertyValue($this->model, $this->vocab, $item, $this->type, $this->clang);
                $this->listItems[] = $listItemValue;
            }
            $iteration++;

            $restNode = $currentNode->getResource('rdf:rest');
            $isEndOfList = $restNode === null || $restNode->getUri() === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';

            if ($isEndOfList) {
                $this->listTruncated = false;
                $currentNode = null;
            } else {
                $currentNode = $restNode;
            }
        }

        if ($currentNode !== null && $itemsLimit > 0 && $iteration >= $itemsLimit) {
            $this->listTruncated = true;
        }
    }

    public function isRdfList()
    {
        return $this->listItems !== null && count($this->listItems) > 0;
    }

    public function getRdfListItems()
    {
        return $this->listItems;
    }

    public function isRdfListTruncated()
    {
        return $this->listTruncated;
    }

}