PerfectOblivion\Valid\Sanitizer\Sanitizer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	parseRulesArray()	0	16	4
A	parseRuleString()	0	16	3
A	applyFilter()	0	17	3
A	sanitize()	0	16	4
A	sanitizeAttribute()	0	10	3

<?php
/**
 * File copied from Waavi/Sanitizer https://github.com/waavi/sanitizer
 * Sanitization functionality to be customized within this project before a 1.0 release.
 */

namespace PerfectOblivion\Valid\Sanitizer;

use Closure;
use Illuminate\Support\Arr;
use InvalidArgumentException;
use Illuminate\Validation\ValidationRuleParser;

class Sanitizer
{
    /** @var array */
    protected $data;

    /** @var array */
    protected $rules;

    /** @var array */
    protected $filters = [
        'capitalize'  => Filters\Capitalize::class,
        'cast'        => Filters\Cast::class,
        'escape'      => Filters\EscapeHTML::class,
        'format_date' => Filters\FormatDate::class,
        'lowercase'   => Filters\Lowercase::class,
        'uppercase'   => Filters\Uppercase::class,
        'trim'        => Filters\Trim::class,
        'strip_tags'  => Filters\StripTags::class,
        'digit'       => Filters\Digit::class,
    ];

    /**
     * Create a new sanitizer instance.
     *
     * @param  array  $data
     * @param  array  $rules      Rules to be applied to each data attribute
     * @param  array  $filters    Available filters for this sanitizer

There is no parameter named $filters. Did you maybe mean $customFilters?

     */
    public function __construct(array $data, array $rules, array $customFilters = [])
    {
        $this->data = $data;
        $this->rules = $this->parseRulesArray($rules);
        $this->filters = array_merge($this->filters, $customFilters);
    }

    /**
     * Parse a rules array.
     *
     * @param  array $rules
     *
     * @return array
     */
    protected function parseRulesArray(array $rules)
    {
        $parsedRules = [];
        $rawRules = (new ValidationRuleParser($this->data))->explode($rules);

        foreach ($rawRules->rules as $attribute => $attributeRules) {
            foreach ($attributeRules as $attributeRule) {
                $parsedRule = $this->parseRuleString($attributeRule);
                if ($parsedRule) {

The expression $parsedRule of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $parsedRules[$attribute][] = $parsedRule;
                }
            }
        }

        return $parsedRules;
    }

    /**
     * Parse a rule string formatted as filterName:option1, option2 into an array formatted as [name => filterName, options => [option1, option2]].
     *
     * @param  string  $rule    Formatted as 'filterName:option1, option2' or just 'filterName'
     *
     * @return array
     */
    protected function parseRuleString($rule)
    {
        if (strpos($rule, ':') !== false) {
            [$name, $options] = explode(':', $rule, 2);

The variable $name seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $options seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

            $options = array_map('trim', explode(',', $options));

The variable $options seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        } else {
            $name = $rule;
            $options = [];
        }

        if (! $name) {

The variable $name does not seem to be defined for all execution paths leading up to this point.

            return [];
        }

        return compact('name', 'options');
    }

    /**
     * Apply the given filter by its name.
     *
     * @param  mixed  $name
     *
     * @return Filter
     */
    protected function applyFilter($name, $value, $options = [])
    {
        // If the filter does not exist, throw an Exception:
        if (! isset($this->filters[$name])) {
            throw new InvalidArgumentException("No filter found by the name of $name");
        }

        $filter = $this->filters[$name];

        if ($filter instanceof Closure) {
            return call_user_func_array($filter, [$value, $options]);
        } else {
            $filter = new $filter;

            return $filter->apply($value, $options);
        }
    }

    /**
     * Sanitize the given data.
     *
     * @return array
     */
    public function sanitize()
    {
        $sanitized = $this->data;

        foreach ($this->rules as $attr => $rules) {
            if (Arr::has($this->data, $attr)) {
                $value = Arr::get($this->data, $attr);
                foreach ($rules as $rule) {
                    $value = $this->applyFilter($rule['name'], $value, $rule['options']);
                }
                Arr::set($sanitized, $attr, $value);
            }
        }

        return $sanitized;
    }

    /**
     * Sanitize the given attribute.
     *
     * @param  string  $attribute  Attribute name
     * @param  mixed  $value      Attribute value
     *
     * @return mixed   Sanitized value
     */
    protected function sanitizeAttribute($attribute, $value)
    {
        if (isset($this->rules[$attribute])) {
            foreach ($this->rules[$attribute] as $rule) {
                $value = $this->applyFilter($rule['name'], $value, $rule['options']);
            }
        }

        return $value;
    }
}