GeminiLabs\SiteReviews\Modules\Sanitizer

Complexity

Total Complexity

31

Size/Duplication

Total Lines	233
Duplicated Lines	0 %

Test Coverage

Coverage

90.79%

Importance

Changes	7
Bugs	1	Features	2

20 Methods

Rating	Name	Duplication	Size	Complexity
A	sanitizeTextHtml()	0	10	1
A	sanitizeUrl()	0	8	2
A	sanitizeArrayInt()	0	3	1
A	buildSanitizers()	0	9	3
A	sanitizeSlug()	0	3	1
A	sanitizeText()	0	3	1
A	sanitizeTextMultiline()	0	3	1
A	sanitizeArrayString()	0	3	1
A	sanitizeBool()	0	3	1
A	sanitizeArray()	0	3	1
A	sanitizeKey()	0	3	1
A	sanitizeEmail()	0	3	1
A	run()	0	9	3
A	__construct()	0	4	1
A	sanitizeDate()	0	7	2
A	sanitizeInt()	0	3	1
A	sanitizeUserName()	0	8	3
A	sanitizeUserEmail()	0	8	3
A	sanitizeId()	0	8	2
A	sanitizeName()	0	4	1

<?php

namespace GeminiLabs\SiteReviews\Modules;

use GeminiLabs\SiteReviews\Helper;
use GeminiLabs\SiteReviews\Helpers\Arr;
use GeminiLabs\SiteReviews\Helpers\Cast;
use GeminiLabs\SiteReviews\Helpers\Str;

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

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

    public function __construct(array $values = [], array $sanitizers = [])
    {
        $this->sanitizers = $this->buildSanitizers(Arr::consolidate($sanitizers));
        $this->values = Arr::consolidate($values);
    }

    /**
     * @return array|bool|string
     */
    public function run()
    {
        $result = $this->values;
        foreach ($this->values as $key => $value) {
            if (array_key_exists($key, $this->sanitizers)) {
                $result[$key] = call_user_func([$this, $this->sanitizers[$key]], $value);
            }
        }
        return $result;
    }

    /**
     * @param mixed $value
     * @return array
     */
    public function sanitizeArray($value)
    {
        return Arr::consolidate($value);
    }

    /**
     * @param mixed $value
     * @return int[]
     */
    public function sanitizeArrayInt($value)
    {
        return Arr::uniqueInt(Cast::toArray($value));
    }

    /**
     * @param mixed $value
     * @return string[]
     */
    public function sanitizeArrayString($value)
    {
        return array_filter(Cast::toArray($value), 'is_string');
    }

    /**
     * @param mixed $value
     * @return bool
     */
    public function sanitizeBool($value)
    {
        return Cast::toBool($value);
    }

    /**
     * If date is invalid then return an empty string.
     * @param mixed $value
     * @param string $fallback
     * @return string
     */
    public function sanitizeDate($value, $fallback = '')
    {
        $date = strtotime(trim(Cast::toString($value)));
        if (false !== $date) {
            return wp_date('Y-m-d H:i:s', $date);
        }
        return $fallback;
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeEmail($value)
    {
        return sanitize_email(trim(Cast::toString($value)));
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeId($value)
    {
        require_once ABSPATH.WPINC.'/pluggable.php';
        $value = $this->sanitizeSlug($value);
        if (empty($value)) {
            $value = glsr()->prefix.substr(wp_hash(serialize($this->values), 'nonce'), -12, 8);
        }
        return $value;
    }

    /**
     * @param mixed $value
     * @return int
     */
    public function sanitizeInt($value)
    {
        return Cast::toInt($value);
    }

    /**
     * This allows lowercase alphannumeric and underscore characters
     * @param mixed $value
     * @return string
     */
    public function sanitizeKey($value)
    {
        return Str::snakeCase(sanitize_key($this->sanitizeText($value)));
    }

    /**
     * This allows lowercase alpha and underscore characters
     * @param mixed $value
     * @return string
     */
    public function sanitizeName($value)
    {
        $value = Str::snakeCase($this->sanitizeText($value));
        return preg_replace('/[^a-z_]/', '', $value);
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeSlug($value)
    {
        return sanitize_title($this->sanitizeText($value));
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeText($value)
    {
        return sanitize_text_field(trim(Cast::toString($value)));
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeTextHtml($value)
    {
        global $allowedposttags;
        $allowedHtml = [
            'a' => glsr_get($allowedposttags, 'a'),
            'em' => glsr_get($allowedposttags, 'em'),
            'strong' => glsr_get($allowedposttags, 'strong'),
        ];
        $allowedHtml = glsr()->filterString('sanitize/allowed-html-tags', $allowedHtml, $allowedposttags);
        return wp_kses(trim(Cast::toString($value)), $allowedHtml);
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeTextMultiline($value)
    {
        return sanitize_textarea_field(trim(Cast::toString($value)));
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeUrl($value)
    {
        $url = trim(Cast::toString($value));
        if (!Str::startsWith('http://, https://', $url)) {
            $url = Str::prefix($url, 'https://');
        }
        $url = wp_http_validate_url($url);
        return esc_url_raw(Cast::toString($url));
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeUserEmail($value)
    {
        $user = wp_get_current_user();
        $value = trim(Cast::toString($value));
        if ($user->exists() && !glsr()->retrieveAs('bool', 'import', false)) {
            return Helper::ifEmpty($value, $user->user_email);
        }
        return sanitize_email($value);
    }

    /**
     * @param mixed $value
     * @return string
     */
    public function sanitizeUserName($value)
    {
        $user = wp_get_current_user();
        $value = trim(Cast::toString($value));
        if ($user->exists() && !glsr()->retrieveAs('bool', 'import', false)) {
            return Helper::ifEmpty($value, $user->display_name);
        }
        return sanitize_text_field($value);
    }

    /**
     * @return array
     */
    protected function buildSanitizers(array $sanitizers)
    {
        foreach ($sanitizers as $key => &$type) {
            $method = Helper::buildMethodName($type, 'sanitize');
            $type = method_exists($this, $method)
                ? $method
                : 'sanitizeText';
        }
        return $sanitizers;
    }
}