VocabularyConfig - Code Metrics - Inspection of "using the new VocabularyConfig in the rest api" - NatLibFi/Skosmos - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fdd253...65cf44 )

by Henri

created 2015-11-27 13:41 UTC

VocabularyConfig B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	338
Duplicated Lines	6.21 %

Coupling/Cohesion

Components	1
Dependencies	5

Metric	Value
wmc	48
lcom	1
cbo	5
dl	21
loc	338
rs	8.4865

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getBoolean()	0	9	2
A	getLiteral()	0	16	4
A	getDefaultLanguage()	0	15	3
A	getAlphabeticalFull()	0	4	1
A	getShortName()	0	9	2
A	getFeedbackRecipient()	0	5	2
A	getTitle()	0	4	1
A	sortByNotation()	0	4	1
A	showChangeList()	0	4	1
B	getDataURLs()	0	27	5
A	getGroupClassURI()	0	9	2
A	getArrayClassURI()	0	9	2
A	getAdditionalSearchProperties()	9	15	3
A	hasMultiLingualProperty()	12	17	4
A	getShowHierarchy()	0	4	1
A	showConceptSchemesInHierarchy()	0	4	1
A	getExternalResourcesLoading()	0	4	1
A	getShowLangCodes()	0	4	1
A	getIndexClasses()	0	9	2
A	getLanguages()	0	12	2
A	getDefaultSidebarView()	0	12	4
A	getId()	0	14	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like VocabularyConfig often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use VocabularyConfig, and based on these observations, apply Extract Interface, too.

<?php

/**
 * VocabularyConfig provides access to the vocabulary configuration defined in vocabularies.ttl.
 */
class VocabularyConfig extends DataObject
namespace YourVendor;

class YourClass { }
{
    public function __construct($resource) 
    {
      $this->resource = $resource;
    }

    /**
     * Returns a boolean value based on a literal value from the vocabularies.ttl configuration.
     * @param string $property the property to query
     * @param boolean $default the default value if the value is not set in configuration
     */
    private function getBoolean($property, $default = false)
    {
        $val = $this->resource->getLiteral($property);
        if ($val) {
            return filter_var($val->getValue(), FILTER_VALIDATE_BOOLEAN);
        }

        return $default;
    }
    
    /**
     * Returns a boolean value based on a literal value from the vocabularies.ttl configuration.
     * @param string $property the property to query
     * @param string $lang preferred language for the literal,
     */
    private function getLiteral($property, $lang=null)
    {
        if (!isset($lang)) {;
            $lang = $this->getEnvLang();
        }

        $literal = $this->resource->getLiteral($property, $lang);
        if ($literal) {
            return $literal->getValue();
        }

        // not found with selected language, try any language
        $literal = $this->resource->getLiteral($property);
        if ($literal)
          return $literal->getValue();
    }

    /**
     * Get the default language of this vocabulary
     * @return string default language, e.g. 'en'
     */

    public function getDefaultLanguage()
    {
        $deflang = $this->resource->getLiteral('skosmos:defaultLanguage');
        if ($deflang) {
            return $deflang->getValue();
        }

        $langs = $this->getLanguages();
        $deflang = reset($langs); // picking the first one from the list with reset since the keys are not numeric
        if (sizeof($langs) > 1) {
            trigger_error("Default language for vocabulary '" . $this->getShortName() . "' unknown, choosing '$deflang'.", E_USER_WARNING);
        }

        return $deflang;
    }

    /**
     * Wether the alphabetical index is small enough to be shown all at once.
     * @return boolean true if all concepts can be shown at once.
     */
    public function getAlphabeticalFull()
    {
        return $this->getBoolean('skosmos:fullAlphabeticalIndex');
    }

    /**
     * Returns a short name for a vocabulary if configured. If that has not been set
     * using vocabId as a fallback.
     * @return string
     */
    public function getShortName()
    {
        $shortname = $this->getLiteral('skosmos:shortName');
        if ($shortname) 
          return $shortname;

        // if no shortname exists fall back to the id
        return $this->getId();
    }

    /**
     * Get the vocabulary feedback e-mail address and return it.
     *
     * @return string e-mail address or null if not defined.
     */
    public function getFeedbackRecipient()
    {
        $email = $this->resource->get('skosmos:feedbackRecipient');
        return isset($email) ? $email->getValue() : null;
    }

    /**
     * Returns the human readable vocabulary title.
     * @return string the title of the vocabulary
     */
    public function getTitle($lang = null)
    {
        return $this->getLiteral('dc:title', $lang);
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean
     */
    public function sortByNotation()
    {
        return $this->getBoolean('skosmos:sortByNotation');
    }
    
    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean
     */
    public function showChangeList()
    {
        return $this->getBoolean('skosmos:showChangeList');
    }

    /**
     * get the URLs from which the vocabulary data can be downloaded
     * @return array Array with MIME type as key, URL as value
     */
    public function getDataURLs()
    {
        $ret = array();
        $urls = $this->resource->allResources("void:dataDump");
        foreach ($urls as $url) {
            // first try dc:format and dc11:format
            $mimetypelit = $url->getLiteral('dc:format');
            if ($mimetypelit === null) {
                $mimetypelit = $url->getLiteral('dc11:format');
            }

            // if still not found, guess MIME type using file extension
            if ($mimetypelit !== null) {
                $mimetype = $mimetypelit->getValue();
            } else {
                $format = EasyRdf_Format::guessFormat(null, $url->getURI());
                if ($format === null) {
                    trigger_error("Could not guess format for <$url>.", E_USER_WARNING);
                    continue;
                }
                $mimetypes = array_keys($format->getMimeTypes());
                $mimetype = $mimetypes[0];
            }
            $ret[$mimetype] = $url->getURI();
        }
        return $ret;
    }

    /**
     * Returns the class URI used for concept groups in this vocabulary,
     * or null if not set.
     * @return string group class URI or null
     */

    public function getGroupClassURI()
    {
        $val = $this->resource->getResource("skosmos:groupClass");
        if ($val) {
            return $val->getURI();
        }

        return null;
    }

    /**
     * Returns the class URI used for thesaurus arrays in this vocabulary,
     * or null if not set.
     * @return string array class URI or null
     */

    public function getArrayClassURI()
    {
        $val = $this->resource->getResource("skosmos:arrayClass");
        if ($val) {
            return $val->getURI();
        }

        return null;
    }

    /**
     * Returns custom properties displayed on the search page if configured.
     * @return string array class URI or null
     */

    public function getAdditionalSearchProperties()
    {
        $resources = $this->resource->allResources("skosmos:showPropertyInSearch");
        $ret = array();
        foreach ($resources as $res) {

            $prop = $res->getURI();
            if (EasyRdf_Namespace::shorten($prop) !== null) // shortening property labels if possible
            {
                $prop = EasyRdf_Namespace::shorten($prop);
            }

            $ret[] = $prop;
        }
        return $ret;
    }

    /**
     * Queries whether the property should be shown with all the label language variations.
     * @param string $property
     * @return boolean
     */
    public function hasMultiLingualProperty($property)
    {
        $resources = $this->resource->allResources("skosmos:hasMultiLingualProperty");
        foreach ($resources as $res) {

            $prop = $res->getURI();
            if (EasyRdf_Namespace::shorten($prop) !== null) // shortening property labels if possible
            {
                $prop = EasyRdf_Namespace::shorten($prop);
            }

            if ($prop === $property) {
                return true;
            }

        }
        return false;
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean
     */
    public function getShowHierarchy()
    {
        return $this->getBoolean('skosmos:showTopConcepts');
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean
     */
    public function showConceptSchemesInHierarchy()
    {
        return $this->getBoolean('skosmos:conceptSchemesInHierarchy');
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean defaults to true if fetching hasn't been explicitly denied.
     */
    public function getExternalResourcesLoading()
    {
        return $this->getBoolean('skosmos:loadExternalResources', true);
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return boolean
     */
    public function getShowLangCodes()
    {
        return $this->getBoolean('skosmos:explicitLanguageTags');
    }

    /**
     * Returns a boolean value set in the vocabularies.ttl config.
     * @return array array of concept class URIs (can be empty)
     */
    public function getIndexClasses()
    {
        $resources = $this->resource->allResources("skosmos:indexShowClass");
        $ret = array();
        foreach ($resources as $res) {
            $ret[] = $res->getURI();
        }
        return $ret;
    }

    /**
     * Get the languages supported by this vocabulary
     * @return array languages supported by this vocabulary (as language tag strings)
     */
    public function getLanguages()
    {
        $langs = $this->resource->allLiterals('skosmos:language');
        $ret = array();
        foreach ($langs as $lang) {
            $langlit = Punic\Language::getName($lang->getValue(), $this->getEnvLang());
            $ret[$langlit] = $lang->getValue();
        }
        ksort($ret);

        return $ret;
    }

    /**
     * Returns the vocabulary default sidebar view.
     * @return string name of the view
     */
    public function getDefaultSidebarView()
    {
        $defview = $this->resource->getLiteral('skosmos:defaultSidebarView');
        if ($defview) {
            $value = $defview->getValue();
            if ($value === 'groups' || $value === 'hierarchy') {
                return $value;
            }

        }
        return 'alphabetical'; // if not defined displaying the alphabetical index
    }

    /**
     * Extracts the vocabulary id string from the baseuri of the vocabulary.
     * @return string identifier eg. 'mesh'.
     */
    public function getId()
    {
        $uriparts = explode("#", $this->resource->getURI());
        if (count($uriparts) != 1)
        // hash namespace
        {
            return $uriparts[1];
        }

        // slash namespace
        $uriparts = explode("/", $this->resource->getURI());

        return $uriparts[count($uriparts) - 1];
    }
}


1		<?php
2
3		/**
4		* VocabularyConfig provides access to the vocabulary configuration defined in vocabularies.ttl.
5		*/
6		class VocabularyConfig extends DataObject
		0 ignored issues – show Coding Style Compatibility introduced 2015-11-27 13:45 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
7		{
8		public function __construct($resource)
9		{
10		$this->resource = $resource;
11		}
12
13		/**
14		* Returns a boolean value based on a literal value from the vocabularies.ttl configuration.
15		* @param string $property the property to query
16		* @param boolean $default the default value if the value is not set in configuration
17		*/
18		private function getBoolean($property, $default = false)
19		{
20		$val = $this->resource->getLiteral($property);
21		if ($val) {
22		return filter_var($val->getValue(), FILTER_VALIDATE_BOOLEAN);
23		}
24
25		return $default;
26		}
27
28		/**
29		* Returns a boolean value based on a literal value from the vocabularies.ttl configuration.
30		* @param string $property the property to query
31		* @param string $lang preferred language for the literal,
32		*/
33		private function getLiteral($property, $lang=null)
34		{
35		if (!isset($lang)) {;
36		$lang = $this->getEnvLang();
37		}
38
39		$literal = $this->resource->getLiteral($property, $lang);
40		if ($literal) {
41		return $literal->getValue();
42		}
43
44		// not found with selected language, try any language
45		$literal = $this->resource->getLiteral($property);
46		if ($literal)
47		return $literal->getValue();
48		}
49
50		/**
51		* Get the default language of this vocabulary
52		* @return string default language, e.g. 'en'
53		*/
54
55		public function getDefaultLanguage()
56		{
57		$deflang = $this->resource->getLiteral('skosmos:defaultLanguage');
58		if ($deflang) {
59		return $deflang->getValue();
60		}
61
62		$langs = $this->getLanguages();
63		$deflang = reset($langs); // picking the first one from the list with reset since the keys are not numeric
64		if (sizeof($langs) > 1) {
65		trigger_error("Default language for vocabulary '" . $this->getShortName() . "' unknown, choosing '$deflang'.", E_USER_WARNING);
66		}
67
68		return $deflang;
69		}
70
71		/**
72		* Wether the alphabetical index is small enough to be shown all at once.
73		* @return boolean true if all concepts can be shown at once.
74		*/
75		public function getAlphabeticalFull()
76		{
77		return $this->getBoolean('skosmos:fullAlphabeticalIndex');
78		}
79
80		/**
81		* Returns a short name for a vocabulary if configured. If that has not been set
82		* using vocabId as a fallback.
83		* @return string
84		*/
85		public function getShortName()
86		{
87		$shortname = $this->getLiteral('skosmos:shortName');
88		if ($shortname)
89		return $shortname;
90
91		// if no shortname exists fall back to the id
92		return $this->getId();
93		}
94
95		/**
96		* Get the vocabulary feedback e-mail address and return it.
97		*
98		* @return string e-mail address or null if not defined.
99		*/
100		public function getFeedbackRecipient()
101		{
102		$email = $this->resource->get('skosmos:feedbackRecipient');
103		return isset($email) ? $email->getValue() : null;
104		}
105
106		/**
107		* Returns the human readable vocabulary title.
108		* @return string the title of the vocabulary
109		*/
110		public function getTitle($lang = null)
111		{
112		return $this->getLiteral('dc:title', $lang);
113		}
114
115		/**
116		* Returns a boolean value set in the vocabularies.ttl config.
117		* @return boolean
118		*/
119		public function sortByNotation()
120		{
121		return $this->getBoolean('skosmos:sortByNotation');
122		}
123
124		/**
125		* Returns a boolean value set in the vocabularies.ttl config.
126		* @return boolean
127		*/
128		public function showChangeList()
129		{
130		return $this->getBoolean('skosmos:showChangeList');
131		}
132
133		/**
134		* get the URLs from which the vocabulary data can be downloaded
135		* @return array Array with MIME type as key, URL as value
136		*/
137		public function getDataURLs()
138		{
139		$ret = array();
140		$urls = $this->resource->allResources("void:dataDump");
141		foreach ($urls as $url) {
142		// first try dc:format and dc11:format
143		$mimetypelit = $url->getLiteral('dc:format');
144		if ($mimetypelit === null) {
145		$mimetypelit = $url->getLiteral('dc11:format');
146		}
147
148		// if still not found, guess MIME type using file extension
149		if ($mimetypelit !== null) {
150		$mimetype = $mimetypelit->getValue();
151		} else {
152		$format = EasyRdf_Format::guessFormat(null, $url->getURI());
153		if ($format === null) {
154		trigger_error("Could not guess format for <$url>.", E_USER_WARNING);
155		continue;
156		}
157		$mimetypes = array_keys($format->getMimeTypes());
158		$mimetype = $mimetypes[0];
159		}
160		$ret[$mimetype] = $url->getURI();
161		}
162		return $ret;
163		}
164
165		/**
166		* Returns the class URI used for concept groups in this vocabulary,
167		* or null if not set.
168		* @return string group class URI or null
169		*/
170
171		public function getGroupClassURI()
172		{
173		$val = $this->resource->getResource("skosmos:groupClass");
174		if ($val) {
175		return $val->getURI();
176		}
177
178		return null;
179		}
180
181		/**
182		* Returns the class URI used for thesaurus arrays in this vocabulary,
183		* or null if not set.
184		* @return string array class URI or null
185		*/
186
187		public function getArrayClassURI()
188		{
189		$val = $this->resource->getResource("skosmos:arrayClass");
190		if ($val) {
191		return $val->getURI();
192		}
193
194		return null;
195		}
196
197		/**
198		* Returns custom properties displayed on the search page if configured.
199		* @return string array class URI or null
200		*/
201
202		public function getAdditionalSearchProperties()
203		{
204		$resources = $this->resource->allResources("skosmos:showPropertyInSearch");
205		$ret = array();
206	View Code Duplication	foreach ($resources as $res) {
		0 ignored issues – show Duplication introduced 2015-11-27 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
207		$prop = $res->getURI();
208		if (EasyRdf_Namespace::shorten($prop) !== null) // shortening property labels if possible
209		{
210		$prop = EasyRdf_Namespace::shorten($prop);
211		}
212
213		$ret[] = $prop;
214		}
215		return $ret;
216		}
217
218		/**
219		* Queries whether the property should be shown with all the label language variations.
220		* @param string $property
221		* @return boolean
222		*/
223		public function hasMultiLingualProperty($property)
224		{
225		$resources = $this->resource->allResources("skosmos:hasMultiLingualProperty");
226	View Code Duplication	foreach ($resources as $res) {
		0 ignored issues – show Duplication introduced 2015-11-27 13:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
227		$prop = $res->getURI();
228		if (EasyRdf_Namespace::shorten($prop) !== null) // shortening property labels if possible
229		{
230		$prop = EasyRdf_Namespace::shorten($prop);
231		}
232
233		if ($prop === $property) {
234		return true;
235		}
236
237		}
238		return false;
239		}
240
241		/**
242		* Returns a boolean value set in the vocabularies.ttl config.
243		* @return boolean
244		*/
245		public function getShowHierarchy()
246		{
247		return $this->getBoolean('skosmos:showTopConcepts');
248		}
249
250		/**
251		* Returns a boolean value set in the vocabularies.ttl config.
252		* @return boolean
253		*/
254		public function showConceptSchemesInHierarchy()
255		{
256		return $this->getBoolean('skosmos:conceptSchemesInHierarchy');
257		}
258
259		/**
260		* Returns a boolean value set in the vocabularies.ttl config.
261		* @return boolean defaults to true if fetching hasn't been explicitly denied.
262		*/
263		public function getExternalResourcesLoading()
264		{
265		return $this->getBoolean('skosmos:loadExternalResources', true);
266		}
267
268		/**
269		* Returns a boolean value set in the vocabularies.ttl config.
270		* @return boolean
271		*/
272		public function getShowLangCodes()
273		{
274		return $this->getBoolean('skosmos:explicitLanguageTags');
275		}
276
277		/**
278		* Returns a boolean value set in the vocabularies.ttl config.
279		* @return array array of concept class URIs (can be empty)
280		*/
281		public function getIndexClasses()
282		{
283		$resources = $this->resource->allResources("skosmos:indexShowClass");
284		$ret = array();
285		foreach ($resources as $res) {
286		$ret[] = $res->getURI();
287		}
288		return $ret;
289		}
290
291		/**
292		* Get the languages supported by this vocabulary
293		* @return array languages supported by this vocabulary (as language tag strings)
294		*/
295		public function getLanguages()
296		{
297		$langs = $this->resource->allLiterals('skosmos:language');
298		$ret = array();
299		foreach ($langs as $lang) {
300		$langlit = Punic\Language::getName($lang->getValue(), $this->getEnvLang());
301		$ret[$langlit] = $lang->getValue();
302		}
303		ksort($ret);
304
305		return $ret;
306		}
307
308		/**
309		* Returns the vocabulary default sidebar view.
310		* @return string name of the view
311		*/
312		public function getDefaultSidebarView()
313		{
314		$defview = $this->resource->getLiteral('skosmos:defaultSidebarView');
315		if ($defview) {
316		$value = $defview->getValue();
317		if ($value === 'groups' \|\| $value === 'hierarchy') {
318		return $value;
319		}
320
321		}
322		return 'alphabetical'; // if not defined displaying the alphabetical index
323		}
324
325		/**
326		* Extracts the vocabulary id string from the baseuri of the vocabulary.
327		* @return string identifier eg. 'mesh'.
328		*/
329		public function getId()
330		{
331		$uriparts = explode("#", $this->resource->getURI());
332		if (count($uriparts) != 1)
333		// hash namespace
334		{
335		return $uriparts[1];
336		}
337
338		// slash namespace
339		$uriparts = explode("/", $this->resource->getURI());
340
341		return $uriparts[count($uriparts) - 1];
342		}
343		}
344

NatLibFi / Skosmos