Concept::getProperties()

Complexity

Conditions	53
Paths	> 20000

Size

Total Lines	184
Code Lines	93

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function getProperties()
    {
        $properties = array();
        $narrowersByUri = array();
        $inCollection = array();
        $membersArray = array();
        $longUris = $this->resource->propertyUris();
        $duplicates = array();
        $ret = array();

        // looking for collections and linking those with their narrower concepts
        if ($this->vocab->getConfig()->getArrayClassURI() !== null) {

The condition $this->vocab->getConfig()->getArrayClassURI() !== null is always true.

            $collections = $this->graph->allOfType($this->vocab->getConfig()->getArrayClassURI());
            if (sizeof($collections) > 0) {
                // indexing the narrowers once to avoid iterating all of them with every collection
                foreach ($this->resource->allResources('skos:narrower') as $narrower) {
                    $narrowersByUri[$narrower->getUri()] = $narrower;
                }

                foreach ($collections as $coll) {
                    $currCollMembers = $this->getCollectionMembers($coll, $narrowersByUri);
                    foreach ($currCollMembers as $collection) {
                        if ($collection->getSubMembers()) {
                            $submembers = $collection->getSubMembers();
                            foreach ($submembers as $member) {
                                $inCollection[$member->getUri()] = true;
                            }

                        }
                    }

                    if (isset($collection) && $collection->getSubMembers()) {
                        $membersArray = array_merge($currCollMembers, $membersArray);
                    }

                }
                $properties['skos:narrower'] = $membersArray;
            }
        }

        foreach ($longUris as &$prop) {
            // storing full URI without brackets in a separate variable
            $longUri = $prop;
            if (EasyRdf\RdfNamespace::shorten($prop) !== null) {
                // shortening property labels if possible
                $prop = $sprop = EasyRdf\RdfNamespace::shorten($prop);
            } else {
                // EasyRdf requires full URIs to be in angle brackets
                $sprop = "<$prop>";
            }

            if (!in_array($prop, $this->deleted) || ($this->isGroup() === false && $prop === 'skos:member')) {

$this->deleted of type mixed is incompatible with the type array expected by parameter $haystack of in_array().

                // retrieve property label and super properties from the current vocabulary first
                $propres = new EasyRdf\Resource($prop, $this->graph);
                $proplabel = $propres->label($this->getLang()) ? $propres->label($this->getLang()) : $propres->label();

                $prophelp = $propres->getLiteral('rdfs:comment|skos:definition', $this->getLang());
                if ($prophelp === null) {
                    // try again without language restriction
                    $prophelp = $propres->getLiteral('rdfs:comment|skos:definition');
                }

                // check if the property is one of the well-known properties for which we have a translation
                // if it is then we can skip the additional lookups in the default graph
                $propkey = (substr($prop, 0, 5) == 'dc11:') ?
                    str_replace('dc11:', 'dc:', $prop) : $prop;
                $is_well_known = ($this->model->getText($propkey) != $propkey);

                // if not found in current vocabulary, look up in the default graph to be able
                // to read an ontology loaded in a separate graph
                // note that this imply that the property has an rdf:type declared for the query to work
                if (!$is_well_known && !$proplabel) {
                    $envLangLabels = $this->model->getDefaultSparql()->queryLabel($longUri, $this->getLang());

                    $defaultPropLabel = $this->model->getDefaultSparql()->queryLabel($longUri, '');

                    if ($envLangLabels) {
                        $proplabel = $envLangLabels[$this->getLang()];
                    } else {
                        if ($defaultPropLabel) {
                            $proplabel = $defaultPropLabel[''];
                        }
                    }
                }

                // look for superproperties in the current graph
                $superprops = array();
                foreach ($this->graph->allResources($prop, 'rdfs:subPropertyOf') as $subi) {
                    $superprops[] = $subi->getUri();
                }

                // also look up superprops in the default graph if not found in current vocabulary
                if (!$is_well_known && (!$superprops || empty($superprops))) {
                    $superprops = $this->model->getDefaultSparql()->querySuperProperties($longUri);
                }

                // we're reading only one super property, even if there are multiple ones
                $superprop = ($superprops) ? $superprops[0] : null;
                if ($superprop) {
                    $superprop = EasyRdf\RdfNamespace::shorten($superprop) ? EasyRdf\RdfNamespace::shorten($superprop) : $superprop;
                }
                $sort_by_notation = $this->vocab->getConfig()->getSortByNotation();
                $propobj = new ConceptProperty($this->model, $prop, $proplabel, $prophelp, $superprop, $sort_by_notation);

It seems like $sort_by_notation can also be of type string; however, parameter $sort_by_notation of ConceptProperty::__construct() does only seem to accept boolean, maybe add an additional type check?

$this->model of type Model is incompatible with the type string expected by parameter $model of ConceptProperty::__construct().

                if ($propobj->getLabel() !== null) {
                    // only display properties for which we have a label
                    $ret[$prop] = $propobj;
                }

                // searching for subproperties of literals too
                if ($superprops) {
                    foreach ($superprops as $subi) {
                        $suburi = EasyRdf\RdfNamespace::shorten($subi) ? EasyRdf\RdfNamespace::shorten($subi) : $subi;
                        $duplicates[$suburi] = $prop;
                    }
                }

                // Iterating through every literal and adding these to the data object.
                foreach ($this->resource->allLiterals($sprop) as $val) {
                    $literal = new ConceptPropertyValueLiteral($this->model, $this->vocab, $this->resource, $val, $prop);
                    // only add literals when they match the content/hit language or have no language defined OR when they are literals of a multilingual property
                    if (isset($ret[$prop]) && ($literal->getLang() === $this->clang || $literal->getLang() === null) || $this->vocab->getConfig()->hasMultiLingualProperty($prop)) {

Consider adding parentheses for clarity. Current Interpretation: (IssetNode && $literal->getLang() === $this->clang || $literal->getLang() === null) || $this->vocab->getConfig()->hasMultiLingualProperty($prop), Probably Intended Meaning: IssetNode && ($literal->getLang() === $this->clang || $literal->getLang() === null || $this->vocab->getConfig()->hasMultiLingualProperty($prop))

                        $ret[$prop]->addValue($literal);
                    }
                }

                // Iterating through every resource and adding these to the data object.
                foreach ($this->resource->allResources($sprop) as $val) {
                    // skipping narrower concepts which are already shown in a collection
                    if ($sprop === 'skos:narrower' && array_key_exists($val->getUri(), $inCollection)) {
                        continue;
                    }

                    // hiding rdf:type property if it's just skos:Concept
                    if ($sprop === 'rdf:type' && $val->shorten() === 'skos:Concept') {
                        continue;
                    }

                    // handled by getMappingProperties()
                    if (in_array($sprop, $this->MAPPING_PROPERTIES)) {
                        continue;
                    }

                    if (isset($ret[$prop])) {
                        // create a ConceptPropertyValue first, assuming the resource exists in current vocabulary
                        $value = new ConceptPropertyValue($this->model, $this->vocab, $val, $prop, $this->clang);
                        $ret[$prop]->addValue($value);
                    }

                }
            }
        }
        // adding narrowers part of a collection
        foreach ($properties as $prop => $values) {
            foreach ($values as $value) {
                $ret[$prop]->addValue($value);
            }
        }

        $groupPropObj = new ConceptProperty($this->model, 'skosmos:memberOf', null);
        foreach ($this->getGroupProperties() as $propVals) {
            foreach ($propVals as $propVal) {
                $groupPropObj->addValue($propVal);
            }
        }
        $ret['skosmos:memberOf'] = $groupPropObj;

        $arrayPropObj = new ConceptProperty($this->model, 'skosmos:memberOfArray', null);
        foreach ($this->getArrayProperties() as $propVals) {
            foreach ($propVals as $propVal) {
                $arrayPropObj->addValue($propVal);
            }
        }
        $ret['skosmos:memberOfArray'] = $arrayPropObj;

        foreach ($ret as $key => $prop) {
            if (sizeof($prop->getValues()) === 0) {
                unset($ret[$key]);
            }
        }

        $ret = $this->removeDuplicatePropertyValues($ret, $duplicates);
        // sorting the properties to the order preferred in the Skosmos concept page.
        return $this->arbitrarySort($ret);
    }