Words::replaceMatches() - Code Metrics - arthurkushman/detox - Measure and Improve Code Quality continuously with Scrutinizer

Words::replaceMatches() A
last analyzed 2020-01-19 10:43 UTC

↳ Parent: Words

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

namespace detox\core;


use detox\dataset\SetContract;
use detox\source\Text;

/**
 * Class Words
 * @package detox\core
 *
 * @property Text text
 */
class Words
{

    public const MAX_SCORE        = 1;
    public const ASTERISKS_MIDDLE = 0.8;
    public const ASTERISKS_LEFT   = 0.5;
    public const ASTERISKS_RIGHT  = 0.6;

    protected $dataSet;
    protected $score = 0;
    protected $text;

    /**
     * Words constructor.
     *
     * @param SetContract $set
     * @param Text $text
     */
    public function __construct(SetContract $set, Text $text)
    {
        $this->dataSet = $set;
        $this->text    = $text;
    }

    /**
     * Finds bad words from *Set and setting score/replace
     */
    public function processWords() : void
    {
        // to match lower case letters in words set array
        $lowerSource = $this->addLowSpaces($this->text->getString());
        /**
         * 1st level checking discrete words with spaces
         * @var string $points
         * @var array $words
         */
        foreach ($this->dataSet->getWords() as $points => $words) {
            foreach ($words as $word) {
                if (mb_strpos($lowerSource, ' ' . $word . ' ') !== false) {
                    $this->score += (float)$points;
                    if ($this->text->isReplaceable()) {
                        $this->replace($word);
                    }
                }
            }
        }
        if ($this->score < self::ASTERISKS_MIDDLE) {
            // 2nd level checking the worst (3 highest levels) words with probability to be mutated ex.: shittyass, crappish, unfuckkish etc
            $slice = array_slice($this->dataSet->getWords(), 0, 3);
            foreach ($slice as $points => $words) {
                foreach ($words as $word) {
                    if (mb_strpos($lowerSource, $word) !== false) {
                        $this->score += (float)$points;
                        if ($this->text->isReplaceable()) {
                            $this->replace($word);
                        }
                    }
                }
            }
        }
        if ($this->score >= self::MAX_SCORE) {
            $this->score = self::MAX_SCORE;
        }
    }

    /**
     * Finds bad words with asterisks and setting score/replace
     */
    public function processPatterns() : void
    {
        $lowerSource = $this->addLowSpaces($this->text->getString());
        if (preg_match_all('/\s(([\w]+)[\*]+([\w]+))\s/', $lowerSource, $matches) > 0) {
            $this->score += (self::ASTERISKS_MIDDLE * count($matches[0]));
            if ($this->text->isReplaceable()) {
                $this->replaceMatches($matches);
            }
        }
        $lowerSource = $this->addLowSpaces($this->text->getString());
        if (preg_match_all('/\s(([\w]+)[\*]+)\s/', $lowerSource, $matches) > 0) {
            $this->score += (self::ASTERISKS_RIGHT * count($matches[0]));
            if ($this->text->isReplaceable()) {
                $this->replaceMatches($matches);
            }
        }
        $lowerSource = $this->addLowSpaces($this->text->getString());
        if (preg_match_all('/\s([\*]+([\w]+))\s/', $lowerSource, $matches) > 0) {
            $this->score += (self::ASTERISKS_LEFT * count($matches[0]));
            if ($this->text->isReplaceable()) {
                $this->replaceMatches($matches);
            }
        }
    }

    /**
     * @param SetContract $set
     */
    public function setData(SetContract $set) : void
    {
        $this->dataSet = $set;
    }

    /**
     * @return float
     */
    public function getScore() : float
    {
        return $this->score;
    }

    /**
     * @param float $score
     */
    public function setScore(float $score) : void
    {
        $this->score = $score;
    }

    /**
     * @param string $str
     * @return string
     */
    protected function addLowSpaces(string $str) : string
    {
        return ' ' . mb_strtolower($str) . ' ';
    }

    /**
     * @param string $phrase word or phrase to replace
     */
    protected function replace(string $phrase) : void
    {
        // todo: slice the word with replacement to prevent WoRd -> word transformations
        $this->text->setString(str_replace($phrase, $this->text->getPrefix() . $this->text->getReplaceChars() . $this->text->getPostfix(),
            mb_strtolower($this->text->getString())));
    }

    private function replaceMatches(array $matches) : void
    {
        /** @var array $matches */
        foreach ($matches[0] as $word) {
            $this->replace($word);
        }
    }

    /**
     * Setter for convenient DI with Text object and it's properties
     * @param Text $text
     */
    public function setText(Text $text) : void
    {
        $this->text = $text;
    }

    /**
     * @return Text
     */
    public function getText() : Text
    {
        return $this->text;
    }

    /**
     * @return SetContract
     */
    public function getDataSet() : SetContract
    {
        return $this->dataSet;
    }

    /**
     * @param SetContract $dataSet
     */
    public function setDataSet(SetContract $dataSet) : void
    {
        $this->dataSet = $dataSet;
    }
}

1			<?php
2
3			namespace detox\core;
4
5
6			use detox\dataset\SetContract;
7			use detox\source\Text;
8
9			/**
10			* Class Words
11			* @package detox\core
12			*
13			* @property Text text
14			*/
15			class Words
16			{
17
18			public const MAX_SCORE = 1;
19			public const ASTERISKS_MIDDLE = 0.8;
20			public const ASTERISKS_LEFT = 0.5;
21			public const ASTERISKS_RIGHT = 0.6;
22
23			protected $dataSet;
24			protected $score = 0;
25			protected $text;
26
27			/**
28			* Words constructor.
29			*
30			* @param SetContract $set
31			* @param Text $text
32			*/
33			public function __construct(SetContract $set, Text $text)
34			{
35			$this->dataSet = $set;
36			$this->text = $text;
37			}
38
39			/**
40			* Finds bad words from *Set and setting score/replace
41			*/
42			public function processWords() : void
43			{
44			// to match lower case letters in words set array
45			$lowerSource = $this->addLowSpaces($this->text->getString());
46			/**
47			* 1st level checking discrete words with spaces
48			* @var string $points
49			* @var array $words
50			*/
51			foreach ($this->dataSet->getWords() as $points => $words) {
52			foreach ($words as $word) {
53			if (mb_strpos($lowerSource, ' ' . $word . ' ') !== false) {
54			$this->score += (float)$points;
55			if ($this->text->isReplaceable()) {
56			$this->replace($word);
57			}
58			}
59			}
60			}
61			if ($this->score < self::ASTERISKS_MIDDLE) {
62			// 2nd level checking the worst (3 highest levels) words with probability to be mutated ex.: shittyass, crappish, unfuckkish etc
63			$slice = array_slice($this->dataSet->getWords(), 0, 3);
64			foreach ($slice as $points => $words) {
65			foreach ($words as $word) {
66			if (mb_strpos($lowerSource, $word) !== false) {
67			$this->score += (float)$points;
68			if ($this->text->isReplaceable()) {
69			$this->replace($word);
70			}
71			}
72			}
73			}
74			}
75			if ($this->score >= self::MAX_SCORE) {
76			$this->score = self::MAX_SCORE;
77			}
78			}
79
80			/**
81			* Finds bad words with asterisks and setting score/replace
82			*/
83			public function processPatterns() : void
84			{
85			$lowerSource = $this->addLowSpaces($this->text->getString());
86			if (preg_match_all('/\s(([\w]+)[\*]+([\w]+))\s/', $lowerSource, $matches) > 0) {
87			$this->score += (self::ASTERISKS_MIDDLE * count($matches[0]));
88			if ($this->text->isReplaceable()) {
89			$this->replaceMatches($matches);
90			}
91			}
92			$lowerSource = $this->addLowSpaces($this->text->getString());
93			if (preg_match_all('/\s(([\w]+)[\*]+)\s/', $lowerSource, $matches) > 0) {
94			$this->score += (self::ASTERISKS_RIGHT * count($matches[0]));
95			if ($this->text->isReplaceable()) {
96			$this->replaceMatches($matches);
97			}
98			}
99			$lowerSource = $this->addLowSpaces($this->text->getString());
100			if (preg_match_all('/\s([\*]+([\w]+))\s/', $lowerSource, $matches) > 0) {
101			$this->score += (self::ASTERISKS_LEFT * count($matches[0]));
102			if ($this->text->isReplaceable()) {
103			$this->replaceMatches($matches);
104			}
105			}
106			}
107
108			/**
109			* @param SetContract $set
110			*/
111			public function setData(SetContract $set) : void
112			{
113			$this->dataSet = $set;
114			}
115
116			/**
117			* @return float
118			*/
119			public function getScore() : float
120			{
121			return $this->score;
122			}
123
124			/**
125			* @param float $score
126			*/
127			public function setScore(float $score) : void
128			{
129			$this->score = $score;
130			}
131
132			/**
133			* @param string $str
134			* @return string
135			*/
136			protected function addLowSpaces(string $str) : string
137			{
138			return ' ' . mb_strtolower($str) . ' ';
139			}
140
141			/**
142			* @param string $phrase word or phrase to replace
143			*/
144			protected function replace(string $phrase) : void
145			{
146			// todo: slice the word with replacement to prevent WoRd -> word transformations
147			$this->text->setString(str_replace($phrase, $this->text->getPrefix() . $this->text->getReplaceChars() . $this->text->getPostfix(),
148			mb_strtolower($this->text->getString())));
149			}
150
151			private function replaceMatches(array $matches) : void
152			{
153			/** @var array $matches */
154			foreach ($matches[0] as $word) {
155			$this->replace($word);
156			}
157			}
158
159			/**
160			* Setter for convenient DI with Text object and it's properties
161			* @param Text $text
162			*/
163			public function setText(Text $text) : void
164			{
165			$this->text = $text;
166			}
167
168			/**
169			* @return Text
170			*/
171			public function getText() : Text
172			{
173			return $this->text;
174			}
175
176			/**
177			* @return SetContract
178			*/
179			public function getDataSet() : SetContract
180			{
181			return $this->dataSet;
182			}
183
184			/**
185			* @param SetContract $dataSet
186			*/
187			public function setDataSet(SetContract $dataSet) : void
188			{
189			$this->dataSet = $dataSet;
190			}
191			}

arthurkushman / detox

Words::replaceMatches() A last analyzed 2020-01-19 10:43 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Words::replaceMatches() A
last analyzed 2020-01-19 10:43 UTC