SmsaSDK\Concerns\ValidateData

Complexity

Total Complexity

16

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

97.92%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	validate()	0	14	2
B	validateMissingArguments()	0	19	5
A	validateMethodHasDefinedArguments()	0	18	4
A	validateArgumentsType()	0	8	2
A	validateMethodExistance()	0	8	2
A	getBaseName()	0	4	1

<?php

namespace SmsaSDK\Concerns;

use ReflectionClass;
use SmsaSDK\Config;
use SmsaSDK\Exceptions\InvalidArgumentException;
use SmsaSDK\Exceptions\UndefinedMethodException;

trait ValidateData
{
    /**
     * validate
     * Insert description here.
     *
     * @param $arguments
     * @param $class
     *
     * @return
     */
    private function validate($arguments, $class)

This method is not used, and could be removed.

    {
        $this->validateMethodExistance($class);

        $this->validateArgumentsType($arguments, $class);

        $this->reflection = new ReflectionClass($class);

The property reflection does not exist. Did you maybe forget to declare it?

        $this->validateMethodHasDefinedArguments($arguments, $class);

        if ($this->nullValues === null) {

The property nullValues does not exist. Did you maybe forget to declare it?

            $this->validateMissingArguments($arguments, $class);
        }
    }

    /**
     * validateMissingArguments
     * Insert description here.
     *
     * @param $arguments
     * @param $class
     *
     * @return
     */
    private function validateMissingArguments($arguments, $class)
    {
        $missingArguments = [];
        $keys = array_keys($arguments);
        $commonKeys = array_keys(Config::getCommonData());
        $properties = $this->getReflectionProperties($this->reflection);

It seems like getReflectionProperties() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        foreach ($properties as $key) {
            if (!in_array($key, $keys) && !in_array($key, $commonKeys)) {
                $missingArguments[] = $key;
            }
        }

        if (count($missingArguments) > 0) {
            $classBaseName = $this->getBaseName($class);

            throw new InvalidArgumentException("calling the method [$classBaseName] some arguments are missing: [".implode(', ', $missingArguments).']. required arguments: ['.implode(', ', $properties).'].');
        }
    }

    /**
     * validateMethodHasDefinedArguments
     * Insert description here.
     *
     * @param $arguments
     * @param $class
     *
     * @return
     */
    private function validateMethodHasDefinedArguments($arguments, $class)
    {
        $unknownArguments = [];

        foreach ($arguments as $key => $value) {
            $setterMethod = $this->getSetterMethodFromKey($key);

It seems like getSetterMethodFromKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            if (!$this->reflection->hasMethod($setterMethod)) {
                $unknownArguments[] = $key;
            }
        }

        if (count($unknownArguments) > 0) {
            $properties = $this->getReflectionProperties($this->reflection);

It seems like getReflectionProperties() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $classBaseName = $this->getBaseName($class);

            throw new InvalidArgumentException("Argument passed to the method [$classBaseName] is not expected to this method. unknown arguments: [".implode(', ', $unknownArguments).']. required arguments: ['.implode(', ', $properties).'].');
        }
    }

    /**
     * validateArgumentsType
     * Insert description here.
     *
     * @param $arguments
     * @param $class
     *
     * @return
     */
    private function validateArgumentsType($arguments, $class)
    {
        $classBaseName = $this->getBaseName($class);

        if (!is_array($arguments)) {
            throw new InvalidArgumentException("Arguments passed to the method [$classBaseName] should be an array, ".gettype($arguments).' given');
        }
    }

    /**
     * validateMethodExistance
     * Insert description here.
     *
     * @param $class
     *
     * @return
     */
    private function validateMethodExistance($class)
    {
        if (!class_exists($class)) {
            $classBaseName = $this->getBaseName($class);

            throw new UndefinedMethodException("the method [$classBaseName] is not defined, there is no matching class handler at: $class");
        }
    }

    /**
     * getBaseName
     * Insert description here.
     *
     * @param $class
     *
     * @return
     */
    private function getBaseName($class)
    {
        return preg_replace('/.*\\\\/', '', $class);
    }
}