EndelWar\Spammer\Validator

Complexity

Total Complexity

23

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	validateInputCorpusPath()	0	12	3
A	validateInputCount()	0	4	2
A	validateInputServerIP()	0	4	2
A	validateInputServerPort()	0	4	4
A	validateInput()	0	29	5
A	isValidDomain()	0	6	1
A	validateInputToFrom()	0	16	5
A	__construct()	0	3	1

<?php

namespace EndelWar\Spammer;

use Symfony\Component\Console\Input\InputInterface;

class Validator
{
    /** @var InputInterface $input */
    private $input;

    public function __construct(InputInterface $input)
    {
        $this->input = $input;
    }

    /**
     * @throws \InvalidArgumentException
     * @return array
     */
    public function validateInput(): array
    {
        $validInput = [];
        $validInput['smtpServerIp'] = $this->input->getOption('server');
        $this->validateInputServerIP($validInput['smtpServerIp']);

It seems like $validInput['smtpServerIp'] can also be of type string[]; however, parameter $ip of EndelWar\Spammer\Validator::validateInputServerIP() does only seem to accept string, maybe add an additional type check?

        $validInput['smtpServerPort'] = $this->input->getOption('port');
        $this->validateInputServerPort($validInput['smtpServerPort']);

        $validInput['corpusPath'] = $this->validateInputCorpusPath($this->input->getOption('set-corpus-path'));

It seems like $this->input->getOption('set-corpus-path') can also be of type string[]; however, parameter $path of EndelWar\Spammer\Validator::validateInputCorpusPath() does only seem to accept string, maybe add an additional type check?

        $validInput['count'] = false;
        $validInput['locale'] = false;
        if (false === $validInput['corpusPath']) {
            $validInput['count'] = (int)$this->input->getOption('count');
            $this->validateInputCount($validInput['count']);

            $validInput['locale'] = $this->input->getOption('locale');
        }

        $validInput['to'] = $this->validateInputToFrom($this->input->getOption('to'));

        $validInput['from'] = $this->validateInputToFrom($this->input->getOption('from'));

        if (false !== $validInput['corpusPath'] && (false !== $validInput['count'] || false !== $validInput['locale'])) {
            throw new \InvalidArgumentException('Cannot set both corpus path and count or locale');
        }

        return $validInput;
    }

    /**
     * @param string $ip
     * @throws \InvalidArgumentException
     */
    private function validateInputServerIP($ip)
    {
        if (!filter_var($ip, FILTER_VALIDATE_IP)) {
            throw new \InvalidArgumentException('server option is not a valid IP');
        }
    }

    /**
     * @param int $port
     * @throws \InvalidArgumentException
     */
    private function validateInputServerPort($port)
    {
        if (!is_numeric($port) || ($port < 0 || $port > 65535)) {

The condition is_numeric($port) is always true.

            throw new \InvalidArgumentException('server port must be a number between 0 and 65536');
        }
    }

    /**
     * @param int $count
     * @throws \InvalidArgumentException
     */
    private function validateInputCount($count)
    {
        if ($count < 1) {
            throw new \InvalidArgumentException('count must be equal or greater than 1 (you want to send email, right?)');
        }
    }

    /**
     * @param $string
     * @throws \InvalidArgumentException
     * @return string
     */
    private function validateInputToFrom($string): string
    {
        if (null === $string) {
            return '';
        }

        $string = strtolower($string);
        if (strpos($string, '@') !== false) {
            if (filter_var($string, FILTER_VALIDATE_EMAIL)) {
                return $string;
            }
        } elseif ($this->isValidDomain($string)) {
            return $string;
        }

        throw new \InvalidArgumentException('To and from must be a valid email address or a FQDN');
    }

    /**
     * @param $domain
     * @return bool|mixed
     */
    private function isValidDomain($domain)
    {
        $domain = strtolower($domain);
        $regex = "/^((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}$/";

        return preg_match($regex, $domain);
    }

    /**
     * @param string $path
     * @throws \InvalidArgumentException
     * @return bool|string
     */
    private function validateInputCorpusPath($path)
    {
        if (null === $path) {

The condition null === $path is always false.

            return false;
        }

        $path = realpath($path);
        if (!is_dir($path)) {
            throw new \InvalidArgumentException('Set a valid directory as corpus path');
        }

        return $path;
    }
}