Zemit\Support\Exposer\Exposer::checkExpose()

Complexity

Conditions	29
Paths	162

Size

Total Lines	114
Code Lines	61

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	27
CRAP Score	168.9213

Importance

Changes	2
Bugs	0	Features	0

<?php
    private static function checkExpose(Builder $builder): void
    {
        $columns = $builder->getColumns();
        $fullKey = $builder->getFullKey();
        $value = $builder->getValue();
        
        // Check if the key itself exists at first
        if (isset($columns[$fullKey])) {
            $column = $columns[$fullKey];
            
            // If boolean, set expose to the boolean value
            if (is_bool($column)) {
                $builder->setExpose($column);
            }
            
            // If callable, set the expose to true, and run the method and passes the builder as parameter
            elseif (is_callable($column)) {
                $builder->setExpose(true);
                $callbackReturn = $column($builder);
                
                // If builder is returned, no nothing
                if ($callbackReturn instanceof BuilderInterface) {
                    $builder = $callbackReturn;
                }
                
                // If string is returned, set expose to true and parse with mb_sprintfn or mb_sprintf
                elseif (is_string($callbackReturn)) {
                    $builder->setExpose(true);
                    $builder->setValue(self::getValue($callbackReturn, $value));
                }
                
                // If bool is returned, set expose to boolean value
                elseif (is_bool($callbackReturn)) {
                    $builder->setExpose($callbackReturn);
                }
                
                // If array is returned, parse the columns from the current context key and merge it with the builder
                elseif (is_array($callbackReturn)) {
                    $columns = self::parseColumnsRecursive($callbackReturn, $builder->getFullKey());
                    
                    // If not set, set expose to false by default
                    if (!isset($columns[$builder->getFullKey()])) {
                        $columns[$builder->getFullKey()] = false;
                    }
                    
                    //@TODO handle with array_merge_recursive and handle array inside the columns parameters ^^
                    $builder->setColumns(array_merge($builder->getColumns(), $columns));

It seems like $builder->getColumns() can also be of type null; however, parameter $arrays of array_merge() does only seem to accept array, maybe add an additional type check?

                }
            }
            
            // If is string, set expose to true and parse with mb_sprintfn or mb_sprintf
            elseif (is_string($column)) {
                $builder->setExpose(true);
                $builder->setValue(self::getValue($column, $value));
            }
        }
        
        // Otherwise, check if a parent key exists
        else {
            $parentKey = $fullKey;
            $parentIndex = false;
            do {
                $parentKey = $parentIndex? substr($parentKey, 0, $parentIndex) : '';
                if (isset($columns[$parentKey])) {
                    $column = $columns[$parentKey];
                    if (is_bool($column)) {
                        $builder->setExpose($column);
                    }
                    elseif (is_callable($column)) {
                        $builder->setExpose(true);
                        $callbackReturn = $column($builder);
                        if ($callbackReturn instanceof BuilderInterface) {
                            $builder = $callbackReturn;
                        }
                        elseif (is_string($callbackReturn)) {
                            $builder->setExpose(true);
                            $builder->setValue(self::getValue($callbackReturn, $value));
                        }
                        elseif (is_bool($callbackReturn)) {
                            $builder->setExpose($callbackReturn);
                        }
                        elseif (is_array($callbackReturn)) {
                            // Since it is a parent, we're not supposed to re-re-merge the existing columns
                        }
                    }
                    elseif (is_string($column)) {
                        $builder->setExpose(false);
                        $builder->setValue(self::getValue($column, $value));
                    }
                    break;
                    // break at the first parent found
                }
            } while ($parentIndex = strrpos($parentKey, '.'));
        }
        
        // Try to find a subentity, or field that has the true value
        $value = $builder->getValue();
        if ((is_array($value) || is_object($value) || is_callable($value))) {
            $subColumns = is_null($columns) ? $columns : array_filter($columns, function ($columnValue, $columnKey) use ($builder) {

The assignment to $subColumns is dead and can be removed.

                
                $ret = strpos($columnKey, $builder->getFullKey()) === 0;

It seems like $builder->getFullKey() can also be of type null; however, parameter $needle of strpos() does only seem to accept string, maybe add an additional type check?

                if ($ret && $columnValue === true) {
                    // expose the current instance (which is the parent of the sub column)
                    $builder->setExpose(true);
                }
                
                return $ret;
            }, ARRAY_FILTER_USE_BOTH);
        }
        
        // check for protected setting
        $key = $builder->getKey();
        if (!$builder->getProtected() && is_string($key) && strpos($key, '_') === 0) {
            $builder->setExpose(false);
        }