App\Text

Complexity

Total Complexity

54

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	10
Bugs	1	Features	3

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
C	parse()	0	22	11
A	sentences()	0	9	3
A	escape()	0	12	1
A	typeof()	0	6	1
A	is()	0	8	2
A	match()	0	4	1
A	matches()	0	6	1
A	contains()	0	8	2
A	onlyWords()	0	10	1
A	toLowerCase()	0	4	1
A	toUpperCase()	0	4	1
A	getContent()	0	4	1
A	setContent()	0	8	1
A	italic()	0	4	1
A	bold()	0	4	1
A	code()	0	7	2
A	image()	0	8	2
A	hr()	0	7	2
A	quote()	0	4	1
A	wrap()	0	20	4
A	before()	0	5	2
A	prepend()	0	4	1
A	after()	0	5	2
A	append()	0	4	1
A	__toString()	0	8	2
A	toString()	0	7	2
A	jsonSerialize()	0	4	1
A	render()	0	4	1

<?php
namespace App;


use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Support\Renderable;

/**
 * Class Text
 * @package App
 */
class Text implements \JsonSerializable, Renderable
{
    /**
     * @var string
     */
    protected $content = '';

    /**
     * Text constructor.
     * @param mixed $content
     */
    public function __construct($content = null)
    {
        if ($content) {
            $this->setContent($content);
        }
    }

    /**
     * @param $result
     * @return null|string
     */
    protected function parse($result)
    {
        switch (true) {
            case is_string($result) || is_int($result) ||
                (is_object($result) && method_exists($result, '__toString')):
                return (string)$result;

            case is_array($result):
                return implode("\n", $result);

            case is_object($result) && method_exists($result, 'toString'):
                return $result->toString();

            case is_object($result) && $result instanceof Arrayable:
                return implode("\n", $result->toArray());

            case ($result instanceof static):
                return $result->getContent();
        }

        return null;
    }


    /**
     * @return Text[]|array
     */
    public function sentences()
    {
        $result = [];
        foreach (preg_split('/(\n|:[a-z_]+:|\.|\){2,})/isu', $this->content) as $text) {
            $text = trim($text);
            if ($text) { $result[] = new Text($text); }
        }
        return $result;
    }

    /**
     * @return Text
     * @TODO Improve regular expressions needed
     */
    public function escape()
    {
        $content = $this->content;

        $content = preg_replace('/(?P<char>(?:_|\*))(.+?)(?P=char)/isu', '\\\$1$2\\\$1', $content);
        $content = preg_replace('/\*\*(.+?)\*\*/isu', '*\\*$1*\\*', $content);
        $content = preg_replace('/\-\-(\-)+/isu', '\-\-\-', $content);
        $content = preg_replace('/\n*^(?!\w\s+)(#)/isu', '\\#', $content);
        $content = preg_replace('/\[(.*?)\]\((.*?)\)/isu', '\\[$1\\]\\($2\\)', $content);

        return new Text($content);
    }

    /**
     * @param $type
     * @return mixed
     */
    public function typeof($type)
    {
        $function = 'is_' . strtolower($type);

        return $function($this->content);
    }

    /**
     * @param $content
     * @param bool $ignoreCase
     * @return bool
     */
    public function is($content, $ignoreCase = false)
    {
        if ($ignoreCase) {
            return mb_strtolower($this->content) === mb_strtolower($content);
        }

        return $this->content === $content;
    }

    /**
     * @param $pattern
     * @return int
     */
    public function match($pattern)
    {
        return preg_match('/^' . $pattern . '$/isu', $this->content);
    }

    /**
     * @param $pattern
     * @return mixed
     */
    public function matches($pattern)
    {
        preg_match('/^' . $pattern . '$/isu', $this->content, $matches);

        return $matches;
    }

    /**
     * @param $content
     * @param $ignoreCase
     * @return string
     */
    public function contains($content, $ignoreCase = false)
    {
        if ($ignoreCase) {
            return mb_strstr(mb_strtolower($this->content), mb_strtolower($content));
        }

        return mb_strstr($this->content, $content);
    }

    /**
     * @return Text
     */
    public function onlyWords()
    {
        $content = $this->content;

        $content = preg_replace('/@[a-z0-9_\-]+/iu', '', $content);
        $content = preg_replace('/[^\s\w]/iu', '', $content);
        $content = str_replace(["\n", "\r"], '', $content);

        return new Text(trim($content));
    }

    /**
     * @return string
     */
    public function toLowerCase()
    {
        return new Text(mb_strtolower($this->content));
    }

    /**
     * @return string
     */
    public function toUpperCase()
    {
        return new Text(mb_strtoupper($this->content));
    }

    /**
     * @return string
     */
    public function getContent()
    {
        return $this->content;
    }

    /**
     * @param $content
     * @return Text
     */
    public function setContent($content)
    {
        $content = $this->parse($content);

        $this->content = $content;

        return $this;
    }

    /**
     * @return Text
     */
    public function italic()
    {
        return $this->wrap('_');
    }

    /**
     * @return Text
     */
    public function bold()
    {
        return $this->wrap('**');
    }

    /**
     * @param string|null $lang
     * @return Text
     */
    public function code(string $lang = null)
    {
        if ($lang === null) {
            return $this->wrap('`');
        }
        return $this->wrap('```' . $lang . "\n", "\n```", false);
    }

    /**
     * @param $src
     * @param bool $after
     * @return Text
     */
    public function image($src, $after = true)
    {
        $code = '![' . $src . '](' . $src . ')';
        if ($after) {
            return $this->after($code);
        }
        return $this->before($code);
    }

    /**
     * @param bool $after
     * @return Text
     */
    public function hr($after = true)
    {
        if ($after) {
            return $this->after('---', true);
        }
        return $this->before('---', true);
    }

    /**
     * @return Text
     */
    public function quote()
    {
        return $this->before('> ');
    }

    /**
     * @param string $symbol
     * @param string|null $symbolAfter
     * @param bool $inline
     * @return $this
     */
    public function wrap(string $symbol, string $symbolAfter = null, $inline = true)
    {
        if ($symbolAfter === null) {
            $symbolAfter = $symbol;
        }

        if ($inline) {
            $result = [];
            $lines = explode("\n", (string)$this);
            foreach ($lines as $line) {
                $result[] = $symbol . $line . $symbolAfter;
            }

            $this->setContent(implode("\n", $result));
        } else {
            $this->setContent($symbol . (string)$this . $symbolAfter);
        }

        return $this;
    }

    /**
     * @param $text
     * @param bool $newline
     * @return Text
     */
    public function before($text, $newline = false)
    {
        $this->content = ($text . ($newline ? "\n" : '')) . $this->content;
        return $this;
    }

    /**
     * @param $text
     * @return Text
     */
    public function prepend($text)
    {
        return $this->before($text, true);
    }

    /**
     * @param $text
     * @param bool $newline
     * @return Text
     */
    public function after($text, $newline = false)
    {
        $this->content .= (($newline ? "\n" : '') . $text);
        return $this;
    }

    /**
     * @param $text
     * @return Text
     */
    public function append($text)
    {
        return $this->after($text, true);
    }

    /**
     * @return string
     */
    public function __toString()
    {
        try {
            return $this->toString();
        } catch (\Throwable $e) {
            return get_class($e) . ': ' . $e->getMessage();
        }
    }

    /**
     * @return string
     */
    public function toString()
    {
        if (strlen($this->content) > 3600) {
            throw new \LogicException('Message size cant be more then 3600 bytes');
        }
        return (string)$this->content;
    }

    /**
     * @return string
     */
    public function jsonSerialize()
    {
        return (string)$this;
    }

    /**
     * @return string
     */
    public function render()
    {
        return $this->toString();
    }
}