Flipbox\Skeleton\Helpers\ObjectHelper

Complexity

Total Complexity

18

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getObjectVars()	0	4	1
B	configure()	0	17	5
A	create()	0	8	1
A	checkConfig()	0	18	3
A	getClassFromConfig()	0	16	2
B	findClassFromConfig()	0	27	6

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipbox/skeleton/blob/master/LICENSE
 * @link       https://github.com/flipbox/skeleton
 */

namespace Flipbox\Skeleton\Helpers;

use Flipbox\Skeleton\Exceptions\InvalidConfigurationException;
use Flipbox\Skeleton\Object\ObjectInterface;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 2.0.0
 */
class ObjectHelper
{
    /**
     * Returns the public member variables of an object.
     *
     * @param ObjectInterface $object
     * @return array
     */
    public static function getObjectVars(ObjectInterface $object)
    {
        return get_object_vars($object);
    }

    /**
     * Configures an object with the initial property values.
     *
     * @param ObjectInterface $object
     * @param $properties
     * @return ObjectInterface
     */
    public static function configure(ObjectInterface $object, $properties)
    {
        // Populate model attributes
        if (!empty($properties)) {
            // To array
            if (!is_array($properties)) {
                $properties = ArrayHelper::toArray($properties, [], false);
            }

            foreach ($properties as $name => $value) {
                if ($object->canSetProperty($name)) {
                    $object->$name = $value;
                }
            }
        }
        return $object;
    }

    /**
     * Create a new object
     *
     * @param $config
     * @param null $instanceOf
     * @return ObjectInterface
     * @throws InvalidConfigurationException
     */
    public static function create($config, $instanceOf = null)
    {
        // Get class from config
        $class = static::checkConfig($config, $instanceOf);

        // New object
        return new $class($config);
    }

    /**
     * Checks the config for a valid class
     *
     * @param $config
     * @param null $instanceOf
     * @param bool $removeClass
     * @return null|string
     * @throws InvalidConfigurationException
     */
    public static function checkConfig(&$config, $instanceOf = null, $removeClass = true)
    {
        // Get class from config
        $class = static::getClassFromConfig($config, $removeClass);

        // Make sure we have a valid class
        if ($instanceOf && !is_subclass_of($class, $instanceOf)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $instanceOf can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            throw new InvalidConfigurationException(
                sprintf(
                    "The class '%s' must be an instance of '%s'",
                    (string)$class,
                    (string)$instanceOf
                )
            );
        }

        return $class;
    }

    /**
     * Get a class from a config
     *
     * @param $config
     * @param bool $removeClass
     * @return string
     * @throws InvalidConfigurationException
     */
    public static function getClassFromConfig(&$config, $removeClass = false)
    {
        // Find class
        $class = static::findClassFromConfig($config, $removeClass);

        if (empty($class)) {
            throw new InvalidConfigurationException(
                sprintf(
                    "The configuration must specify a 'class' property: '%s'",
                    JsonHelper::encode($config)
                )
            );
        }

        return $class;
    }

    /**
     * Find a class from a config
     *
     * @param $config
     * @param bool $removeClass
     * @return null|string
     */
    public static function findClassFromConfig(&$config, $removeClass = false)
    {
        // Normalize the config
        if (is_string($config)) {
            $class = $config;
            $config = '';
        } elseif (is_object($config)) {
            return get_class($config);
        } else {
            // Force Array
            if (!is_array($config)) {
                $config = ArrayHelper::toArray($config, [], false);
            }
            if ($removeClass) {
                if (!$class = ArrayHelper::remove($config, 'class')) {
                    $class = ArrayHelper::remove($config, 'type');
                }
            } else {
                $class = ArrayHelper::getValue(
                    $config,
                    'class',
                    ArrayHelper::getValue($config, 'type')
                );
            }
        }
        return $class;
    }
}