ByJG\AnyDataset\Model\ClassAnnotations

Complexity

Total Complexity

43

Size/Duplication

Total Lines	222
Duplicated Lines	7.21 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes	4
Bugs	2	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	28	5
A	getPropertyList()	0	17	3
A	getPropertyAnnotation()	0	9	3
A	getClassInstance()	0	4	1
A	getClassRefl()	0	4	1
A	getClassName()	0	10	3
A	getClassGetter()	0	7	2
A	getClassPropertyPattern()	0	12	3
A	getClassWriteEmpty()	0	7	2
A	getClassDocType()	0	7	2
A	getClassRdfType()	8	8	2
A	getClassRdfAbout()	8	8	2
A	getClassDefaultPrefix()	0	7	2
A	getClassIsRDF()	0	7	2
A	getClassIgnoreAllClass()	0	7	2
B	getClassNamespace()	0	21	5
A	getClassDontCreateClassNode()	0	7	2
A	setClassRefl()	0	4	1

<?php

namespace ByJG\AnyDataset\Model;

use ReflectionClass;
use ReflectionProperty;
use stdClass;

class ClassAnnotations extends Annotations
{
    protected $classRefl;
    protected $className;
    protected $classGetter;
    protected $classPropertyPattern;
    protected $classWriteEmpty;
    protected $classDocType;
    protected $classRdfType;
    protected $classRdfAbout;
    protected $classDefaultPrefix;
    protected $classIsRDF;
    protected $classIgnoreAllClass;
    protected $classNamespace;
    protected $classDontCreateClassNode;

    protected $propertyList;
    protected $propertyAnnotations = [];

    protected $model;
    protected $forcePropName;

    public function __construct($model, $config = "object", $forcePropName = "")
    {
        $this->model = $model;
        $this->config = $config;
        $this->forcePropName = $forcePropName;

        $this->setClassRefl(new \ReflectionClass(new \stdClass));
        $this->annotations = [];

        if (is_array($model)) {
            $this->model = new stdClass();
            foreach ($model as $key => $value) {
                if (is_numeric($key)) {
                    $key = "__{$key}__";
                }
                $this->model->{$key} = $value;
            }
        }

        if (!$this->model instanceof stdClass) {
            $class = new ReflectionClass($this->model);

            $aux = null;
            preg_match_all('/@(?P<param>\S+)\s*(?P<value>\S+)?\r?\n/', $class->getDocComment(), $aux);
            $this->annotations = $this->adjustParams($aux);
            $this->setClassRefl($class);
        }
    }

    public function getPropertyList()
    {
        if (!$this->propertyList) {
            $this->propertyList = [];
            if ($this->model instanceof stdClass) {
                $this->propertyList = get_object_vars($this->model);
            } else {
                $this->propertyList = $this->getClassRefl()->getProperties(
                    ReflectionProperty::IS_PROTECTED |
                    ReflectionProperty::IS_PRIVATE   |
                    ReflectionProperty::IS_PUBLIC
                );
            }
        }

        return $this->propertyList;
    }

    /**
     *
     * @param ReflectionProperty $property
     * @param string $keyProp
     * @return PropertyAnnotations
     */
    public function getPropertyAnnotation($property, $keyProp = null)
    {
        $propName = ($property instanceof \ReflectionProperty) ? $property->getName() : $keyProp;
        if (!isset($this->propertyAnnotations[$propName])) {
            $this->propertyAnnotations[$propName] = new PropertyAnnotations($this, $this->config, $property, $propName);
        }

        return $this->propertyAnnotations[$propName];
    }

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

    public function getClassRefl()
    {
        return $this->classRefl;
    }

    public function getClassName()
    {
        if (!$this->className) {
            $this->className = $this->forcePropName;
            if (empty($this->className)) {
                $this->className = $this->getAnnotations("nodename", get_class($this->model));
            }
        }
        return $this->className;
    }

    public function getClassGetter()
    {
        if (!$this->classGetter) {
            $this->classGetter = $this->getAnnotations("getter", "get");
        }
        return $this->classGetter;
    }

    public function getClassPropertyPattern($id = null)
    {
        if (!$this->classPropertyPattern) {
            $this->classPropertyPattern = $this->getAnnotations("propertypattern", ['/([^a-zA-Z0-9])/', '']);
        }

        if (!is_null($id)) {
            return $this->classPropertyPattern[$id];
        }

        return $this->classPropertyPattern;
    }

    public function getClassWriteEmpty()
    {
        if (!$this->classWriteEmpty) {
            $this->classWriteEmpty = $this->getAnnotations("writeempty", false);
        }
        return $this->classWriteEmpty;
    }

    public function getClassDocType()
    {
        if (!$this->classDocType) {
            $this->classDocType = $this->getAnnotations("doctype", "xml");
        }
        return $this->classDocType;
    }

    public function getClassRdfType()

This method seems to be duplicated in your project.

    {
        if (!$this->classRdfType) {
            $rdfType = $this->getAnnotations("rdftype", "{HOST}/rdf/class/{CLASS}");
            $this->classRdfType = $this->replaceVars($this->getClassName(), $rdfType);
        }
        return $this->classRdfType;
    }

    public function getClassRdfAbout()

This method seems to be duplicated in your project.

    {
        if (!$this->classRdfAbout) {
            $rdfAbout = $this->getAnnotations("rdfabout", "{HOST}/rdf/instance/{CLASS}/{GetID()}");
            $this->classRdfAbout = $this->replaceVars($this->getClassName(), $rdfAbout);
        }
        return $this->classRdfAbout;
    }

    public function getClassDefaultPrefix()
    {
        if (!$this->classDefaultPrefix) {
            $this->classDefaultPrefix = $this->getAnnotations("defaultprefix", "");
        }
        return $this->classDefaultPrefix;
    }

    public function getClassIsRDF()
    {
        if (!$this->classIsRDF) {
            $this->classIsRDF = ($this->getClassDocType() == "rdf");
        }
        return $this->classIsRDF;
    }

    public function getClassIgnoreAllClass()
    {
        if (!$this->classIgnoreAllClass) {
            $this->classIgnoreAllClass = $this->getAnnotations("ignore", false);
        }
        return $this->classIgnoreAllClass;
    }

    public function getClassNamespace()
    {
        if (!$this->classNamespace) {
            $this->classNamespace = $this->getAnnotations("namespace", []);
            if (!is_array($this->classNamespace) && !empty($this->classNamespace)) {
                $this->classNamespace = [ $this->classNamespace];
            }

            foreach ($this->classNamespace as $key => $value) {
                $prefix = strtok($value, "!");
                $uri = str_replace($prefix . "!", "", $value);

                $this->classNamespace[$key] = [
                    $this->classNamespace[$key],
                    "prefix" => $prefix,
                    "uri" => $this->replaceVars($this->classNamespace[$key], $uri)
                ];
            }
        }
        return $this->classNamespace;
    }

    public function getClassDontCreateClassNode()
    {
        if (!$this->classDontCreateClassNode) {
            $this->classDontCreateClassNode = $this->getAnnotations("dontcreatenode", false);
        }
        return $this->classDontCreateClassNode;
    }


    public function setClassRefl($classRefl)
    {
        $this->classRefl = $classRefl;
    }

}