SmsaSDK\Concerns\MapMethods

Complexity

Total Complexity

12

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	mergeCommonData()	0	11	4
A	getSetterMethodFromKey()	0	4	1
A	fillNull()	0	19	4
A	prepareMethodHandler()	0	19	3

<?php

namespace SmsaSDK\Concerns;

use SmsaSDK\Config;

trait MapMethods
{
    /**
     * mergeCommonData
     * Insert description here.
     *
     * @param $methodHandler
     * @param $arguments
     *
     * @return
     */
    private function mergeCommonData($methodHandler, $arguments = [])
    {
        foreach (Config::getCommonData() as $key => $value) {
            $setterMethod = $this->getSetterMethodFromKey($key);
            if (method_exists($methodHandler, $setterMethod) && !array_key_exists($key, $arguments)) {
                $methodHandler->$setterMethod($value);
            }
        }

        return $methodHandler;
    }

    /**
     * getSetterMethodFromKey
     * Insert description here.
     *
     * @param $key
     *
     * @return
     */
    private function getSetterMethodFromKey($key)
    {
        return 'set'.ucfirst($key);
    }

    /**
     * fillNull
     * Insert description here.
     *
     * @param $arguments
     * @param $value
     *
     * @return
     */
    private function fillNull($arguments, $value)
    {
        $missingArguments = [];
        $keys = array_keys($arguments);
        $commonKeys = array_keys(Config::getCommonData());

$commonKeys is not used, you could remove the assignment.

        $properties = $this->getReflectionProperties($this->reflection);

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

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)) {
                $missingArguments[] = $key;
            }
        }

        foreach ($missingArguments as $key) {
            $arguments[$key] = $value;
        }

        return $arguments;
    }

    /**
     * @param $arguments
     * @param $class
     *
     * @return mixed
     */
    private function prepareMethodHandler($arguments, $class)
    {
        $this->validate($arguments, $class);

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

        if ($this->nullValues !== null) {
            $arguments = $this->fillNull($arguments, $this->nullValues);

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

        }

        $methodHandler = new $class();

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

        $methodHandler = $this->mergeCommonData($methodHandler, $arguments);

        return $methodHandler;
    }
}