midgard\portable\mgdschema\manager

Complexity

Total Complexity

46

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Test Coverage

Coverage

88.15%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get_types()	0	4	1
A	get_inherited_mapping()	0	4	1
A	register_child_class()	0	6	2
A	add_type()	0	20	6
A	get_child_classes()	0	7	2
A	get_fcqn()	0	6	2
C	create_merged_types()	0	46	12
C	initialize()	0	41	12
A	resolve_targetclass()	0	16	4
A	get_type_by_shortname()	0	10	3

<?php
/**
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */

namespace midgard\portable\mgdschema;

use midgard\portable\xmlreader;
use midgard\portable\storage\connection;

class manager
{
    /**
     *
     * @var array
     */
    private $types;

    /**
     *
     * @var array
     */
    private $schemadirs;

    /**
     *
     * @var string
     */
    private $namespace;

    /**
     *
     * @var array
     */
    private $merged_types = [];

    /**
     *
     * @var array
     */
    private $child_classes = [];

    public function __construct(array $schemadirs, $namespace)
    {
        $this->schemadirs = $schemadirs;
        $this->namespace = $namespace;
    }

    public function get_types()
    {
        $this->initialize();
        return $this->types;
    }

    public function get_inherited_mapping()
    {
        $this->initialize();
        return $this->merged_types;
    }

    public function get_child_classes($typename)
    {
        $this->initialize();
        if (array_key_exists($typename, $this->child_classes)) {
            return $this->child_classes[$typename];
        }
        return [];
    }

    public function resolve_targetclass(property $property)
    {
        $this->initialize();

        $fqcn = $this->get_fcqn($property->link['target']);

        if (   array_key_exists($fqcn, $this->types)
            || $property->link['target'] === $property->get_parent()->name) {
            $target_class = $property->link['target'];
        } else {
            if (!array_key_exists($property->link['target'], $this->merged_types)) {
                throw new \Exception('Link to unknown class ' . $property->link['target']);
            }
            $target_class = $this->merged_types[$property->link['target']];
        }
        return $target_class;
    }

    private function initialize()
    {
        if ($this->types !== null) {
            return;
        }
        $reader = new xmlreader;
        $types = $reader->parse(dirname(dirname(__DIR__)) . '/xml/core.xml');

        foreach ($this->schemadirs as $schemadir) {
            foreach (glob($schemadir . '*.xml', GLOB_NOSORT) as $filename) {
                if (!file_exists($filename)) {
                    connection::log()->warning('File exists check for ' . $filename . ' returned false, skipping');
                    continue;
                }
                $types = array_merge($types, $reader->parse($filename));
            }
        }

        $tablemap = [];
        foreach ($types as $name => $type) {
            if ($type->parent) {
                $this->register_child_class($type);
            }

            if (!array_key_exists($type->table, $tablemap)) {
                $tablemap[$type->table] = [];
            }
            $tablemap[$type->table][] = $type;
        }

        foreach ($tablemap as $name => $types) {
            if (count($types) == 1) {
                $this->add_type($types[0]);
                unset($tablemap[$name]);
            }
        }

        // We need to process those separately, to be sure the targets for rewriting links are present
        while ($types = array_pop($tablemap)) {
            if (!$this->create_merged_types($types)) {
                array_push($types, $tablemap);
            }
        }
    }

    private function register_child_class(type $type)
    {
        if (!array_key_exists($type->parent, $this->child_classes)) {
            $this->child_classes[$type->parent] = [];
        }
        $this->child_classes[$type->parent][$type->name] = $type->parentfield;
    }

    /**
     * This sort of provides a workaround for situations where two tables use the same name
     */
    private function create_merged_types(array $types)
    {
        $root_type = null;
        foreach ($types as $i => $type) {
            // TODO: We should have a second pass here that prefers classnames starting with midgard_
            if ($type->extends === '\\midgard\\portable\\api\\mgdobject') {
                $root_type = $type;
                unset($types[$i]);
                break;
            }
        }
        if (empty($root_type)) {
            throw new \Exception('could not determine root type of merged group');
        }

        foreach ($types as $type) {
            foreach ($type->get_properties() as $property) {
                if ($root_type->has_property($property->name)) {
                    $root_property = $root_type->get_property($property->name);
                    if ($root_property->field !== $property->field) {
                        connection::log()->error('Naming collision in ' . $root_type->name . ': Field ' . $type->name . '.' . $property->name . ' cannot use column ' . $property->field);
                    }
                    if ($root_property->type !== $property->type) {
                        connection::log()->warn('Naming collision in ' . $root_type->name . ': Field ' . $type->name . '.' . $property->name . ' cannot use type ' . $property->type);
                    }
                    continue;
                }
                $root_type->add_property($property);
            }

            if (array_key_exists($type->name, $this->child_classes)) {
                foreach ($this->child_classes[$type->name] as $childname => $parentfield) {
                    $child_type = $this->get_type_by_shortname($childname);
                    if ($child_type === null) {
                        return false;
                    }

                    $child_type->parent = $root_type->name;
                    $this->register_child_class($child_type);
                }
                unset($this->child_classes[$type->name]);
            }
            $this->merged_types[$type->name] = $root_type->name;
        }
        $this->add_type($root_type);
        return true;
    }

    private function get_type_by_shortname($classname)
    {
        $fqcn = $this->get_fcqn($classname);
        if (array_key_exists($fqcn, $this->types)) {
            return $this->types[$fqcn];
        } elseif (array_key_exists($classname, $this->merged_types)) {
            $fqcn = $this->get_fcqn($this->merged_types[$classname]);
            return $this->types[$fqcn];
        }
        return null;
    }

    private function add_type(type $type)
    {
        $classname = $type->name;
        // TODO: This should probably be in classgenerator
        if ($classname === 'midgard_user') {
            $type->extends = 'base_user';
        }
        if ($classname === 'midgard_person') {
            $type->extends = 'base_person';
        }
        if ($classname === 'midgard_parameter') {
            $type->extends = 'base_parameter';
        }
        if ($classname === 'midgard_repligard') {
            $type->extends = 'base_repligard';
        }
        if ($classname === 'midgard_attachment') {
            $type->extends = 'base_attachment';
        }
        $this->types[$this->get_fcqn($classname)] = $type;
    }

    private function get_fcqn($classname)
    {
        if (!empty($this->namespace)) {
            return $this->namespace . '\\' . $classname;
        }
        return $classname;
    }
}