BOTK\Model\AbstractModel

Complexity

Total Complexity

39

Size/Duplication

Total Lines	272
Duplicated Lines	0 %

Test Coverage

Coverage

96.3%

Importance

Changes	4
Bugs	2	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	fromStdObject()	0	3	1
A	getStorageObject()	0	3	1
A	constructOptions()	0	9	3
A	getTripleCount()	0	8	3
B	__construct()	0	28	7
A	fromArray()	0	3	1
A	getDroppedFields()	0	3	1
A	asString()	0	3	1
A	addFragment()	0	5	4
A	getOptions()	0	3	1
A	getUri()	0	12	2
A	setIdGenerator()	0	6	1
A	mergeOptions()	0	10	3
A	__toString()	0	3	1
A	getVocabularies()	0	9	3
A	asLinkedData()	0	4	1
A	asArray()	0	3	1
A	getTurtleHeader()	0	9	3
A	asStdObject()	0	3	1

<?php
namespace BOTK\Model;

abstract class AbstractModel 
{
	
	/**
	 * 
	 * MUST be redefined by concrete class with the model schema 
	 * Each array element is composed by a propery name and and property options.
	 * Property option is an array with following (optional) fields:
	 * 		'default' 	a value to be used for the propery
	 * 		'filter' 	a php filter 
	 * 		'options' 	php filter options
	 * 		'flags'		php filter flags
	 * 
	 * Example:array (
	 *	'legalName'			=> array(
	 *							'filter'    => FILTER_CALLBACK,	
	 *	                        'options' 	=> '\BOTK\Filters::FILTER_NORMALIZZE_ADDRESS',
	 *		                   ),
	 *	'alternateName'		=> array(		
                            	'flags'  	=> FILTER_FORCE_ARRAY,
	 * 						),
	 * 	'postalCode'		=> array(	// italian rules
	 *							'filter'    => FILTER_VALIDATE_REGEXP,	
	 *	                        'options' 	=> array('regexp'=>'/^[0-9]{5}$/'),
	 *                      	'flags'  	=> FILTER_REQUIRE_SCALAR,
	 *		                   ),
	 * )
	 */
    protected static $DEFAULT_OPTIONS  = array(
        'base'				=> array(
            'default'	=> 'urn:resource:',
            'filter'    => FILTER_CALLBACK,
            'options' 	=> '\BOTK\Filters::FILTER_VALIDATE_URI',
            'flags'  	=> FILTER_REQUIRE_SCALAR,
        ),
    );
    
    
	/**
	 * known vocabularies
	 */
	protected static $VOCABULARY  = array(
		'rdf'		=> 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
	    'xsd' 		=> 'http://www.w3.org/2001/XMLSchema#',
	    'dct'       => 'http://purl.org/dc/terms/',
	    'void'      => 'http://rdfs.org/ns/void#',
	    'foaf'      => 'http://xmlns.com/foaf/0.1/'
	);
	

	protected $options ;
	
	protected $data;
	protected $rdf =null; //lazy created
	protected $tripleCount=0; //lazy created
	protected $uniqueIdGenerator=null; // dependency injections
	protected $droppedFields = array();
	protected $globalStorage = null;
	

	protected static function mergeOptions( array $options1, array $options2 )
	{
    	foreach($options2 as $property=>$option){
			
			$options1[$property]=isset($options1[$property])
				?array_merge($options1[$property], $option)
				:$option;
    	}
		
		return $options1;
	}


	protected static function constructOptions()
	{
		//http://stackoverflow.com/questions/22377022/using-array-merge-to-initialize-static-class-variable-in-derived-class-based-on
		$thisClass = get_called_class();
		$parentClass = get_parent_class($thisClass);
		$exists = $parentClass?method_exists($parentClass, __FUNCTION__):false; 
		return $exists ? 
			self::mergeOptions($parentClass::constructOptions(), $thisClass::$DEFAULT_OPTIONS) : 

The property DEFAULT_OPTIONS does not exist on string.

			$thisClass::$DEFAULT_OPTIONS;		
	}


	/**
	 * Do not call directlty constructor, use fromArray or other factory methodsinstead
	 */
	protected function __construct(array $data =  [], array $customOptions = [], object $globalStorage = null) 
    { 		
 		$options = self::mergeOptions(self::constructOptions(),$customOptions);
		
		// set default values
		foreach( $options as $property=>$option){	
			if(empty($data[$property]) && isset($option['default'])){
				$data[$property] = $option['default'];
			}
		}

		// ensure data are sanitized and validated
		$sanitizedData = array_filter( filter_var_array($data, $options), function ($var){

It seems like filter_var_array($data, $options) can also be of type null; however, parameter $array of array_filter() does only seem to accept array, maybe add an additional type check?

		    return !is_null($var);
		});
			
		// find and register dropped fields
		foreach($data as $property=>$value){
			if($value && empty($sanitizedData[$property])){
				$this->droppedFields[]=$property;
			}
		}


		$this->options = $options;
		$this->data = $sanitizedData;
		$this->setIdGenerator(function($data){return uniqid();});

The parameter $data is not used and could be removed.

		$this->globalStorage = $globalStorage;
    }
	
	
	
	/**
	 * Create an instance from an associative array
	 */
    public static function fromArray(array $data, array $customOptions = [] , object $globalStorage = null)
	{
	    return new static($data,$customOptions,$globalStorage);
	}
	
	
	/**
	 * Create an instance from an generic standard object
	 */
	public static function fromStdObject( \stdClass $obj, array $customOptions = array(), object $globalStorage = null)
	{
	    return static::fromArray((array)$obj,$customOptions,$globalStorage);
	}

	
	public function getStorageObject()
	{
	    return $this->globalStorage;
	}
	
	
	public static function getVocabularies()
	{
		//http://stackoverflow.com/questions/22377022/using-array-merge-to-initialize-static-class-variable-in-derived-class-based-on
		$thisClass = get_called_class();
		$parentClass = get_parent_class($thisClass);
		$exists = $parentClass?method_exists($parentClass, __FUNCTION__):false; 
		return $exists ? 
			array_merge($parentClass::getVocabularies(), $thisClass::$VOCABULARY) : 

The property VOCABULARY does not exist on string.

			$thisClass::$VOCABULARY;
	}

	
	public static function getTurtleHeader($base=null)
	{
		$vocabulariers = static::getVocabularies();
		$header = empty($base)?'': "@base <$base> .\n";
		foreach( $vocabulariers as $prefix=>$ns ){
	        $header.="@prefix $prefix: <$ns> .\n";
		}
		
		return $header;
	}

	
	public function getDroppedFields()
	{
		return $this->droppedFields;
	}

	
	/**
	 * dependecy injection setter 
	 */
	public function setIdGenerator($generator)
	{
		assert( is_callable($generator));
		$this->uniqueIdGenerator = $generator;
		
		return $this;
	}


	/**
	 * returns an uri
	 */
	public function getUri($id=null, $suffix='')
	{
	    assert(!empty($this->data['base'])) ;
	    
	    $base = (array)$this->data['base']; // base could be an array
	    
	    if (empty($id)) {
	        $idGenerator=$this->uniqueIdGenerator;
	        $id=$idGenerator($this->data);
	    }

	    return $base[0] . $id . $suffix;
	}

	
	public function getOptions()
	{
		return $this->options;
	}


	public function getTripleCount()
	{
		// triple count is computed during rdf creation
		if (!empty($this->data) && is_null($this->rdf)){
			$this->asTurtleFragment();
		}
		
		return $this->tripleCount;
	}
		

	public function asArray()
	{
		return $this->data;
	}	



	public function asStdObject()
	{
		return (object) $this->asArray();
	}
	
	
	/**
	 * metadata not yet implemented
	 */		
	public function asLinkedData() 
	{
	    $base = $this->data['base']?? null;
	    return $this->getTurtleHeader($base) ."\n". $this->asTurtleFragment();
	}
	
	
	public function asString() 
	{
		return $this->asLinkedData();
	}
	
		
	public function __toString() 
	{
		return $this->asString();
	}


	/**
	 * adds a turtle fragment managing cardinality > 1
	 */
	protected function addFragment($format, $var, $sanitize=true){
		foreach((array)$var as $v){
			if($var){
				$this->rdf .= sprintf($format, $sanitize?\BOTK\Filters::FILTER_SANITIZE_TURTLE_STRING($v):$v);
				$this->tripleCount++;
			}
		}
	}

	/**
	 * this must be implemented
	 */
	abstract public function asTurtleFragment();
}