ResponseQueue::concatContinues() - Code Metrics - Inspection of "Merge pull request #2 from axiom-labs/master" - johnnymast/rivescript-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ff7261...4233f0 )

by Johnny

created 2022-01-16 20:35 UTC

ResponseQueue::concatContinues() B

↳ Parent: ResponseQueue

Complexity

Conditions	6
Paths	1

Size

Total Lines	48
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	26
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	48
rs	8.8817

<?php
/*
 * This file is part of Rivescript-php
 *
 * (c) Johnny Mast <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Axiom\Rivescript\Cortex\ResponseQueue;

use Axiom\Collections\Collection;
use Axiom\Rivescript\Cortex\Node;
use Axiom\Rivescript\Traits\Tags;

/**
 * ResponseQueue class
 *
 * The ResponseQueue releases the responses in order of sending them
 * back to the user.
 *
 * PHP version 7.4 and higher.
 *
 * @category Core
 * @package  Cortext\ResponseQueue
 * @author   Johnny Mast <[email protected]>
 * @license  https://opensource.org/licenses/MIT MIT
 * @link     https://github.com/axiom-labs/rivescript-php
 * @since    0.4.0
 */
class ResponseQueue extends Collection
{

    use Tags;


    /**
     * A container with responses.
     *
     * @var Collection<ResponseQueueItem>
     */
    protected Collection $responses;

    /**
     * Store the local interpreter options
     * for this instance in time (since they can change).
     *
     * @var array<string, string>
     */
    protected array $options = [];

    /**
     * The trigger string this ResponseQueue belongs to.
     *
     * @var string
     */
    protected string $trigger = "";

    /**
     * ResponseQueue constructor.
     *
     * @param string $trigger the trigger this queue belongs to.
     */
    public function __construct(string $trigger = "")
    {
        parent::__construct();

        $this->responses = new Collection([]);
        $this->trigger = $trigger;

        $this->options = synapse()->memory->local()->all();
    }

    /**
     * Attach a response to the queue.
     *
     * @param Node $node The node contains information about the command.
     *
     * @return void
     */
    public function attach(Node $node): void
    {
        $type = $this->determineResponseType($node->source());
        $queueItem =  new ResponseQueueItem($node->command(), $type, 0, $this->options);
        $this->responses->put($node->value(), $queueItem);
    }

    /**
     * Sort the responses by order.
     *
     * @param Collection<ResponseQueueItem> $responses The array containing the resources.
     *
     * @return Collection<ResponseQueueItem>
     */
    private function sortResponses(Collection $responses): Collection
    {
        return $responses->sort(
            function ($current, $previous) {
                return ($current->order < $previous->order) ? -1 : 1;
            }
        )->reverse();
    }

    /**
     * Check if a response is allowed to be returned by the bot or not.
     *
     * @param string            $response The response to validate.
     * @param ResponseQueueItem $item     The ResponseQueueItem.
     *
     * @return false|mixed
     */
    private function validateResponse(string $response, ResponseQueueItem $item)
    {
        $response = $this->parseTags($response);
        $responses = synapse()->responses;

        foreach ($responses as $class) {
            if (class_exists("\\Axiom\\Rivescript\\Cortex\\Responses\\{$class}")) {
                $class = "\\Axiom\\Rivescript\\Cortex\\Responses\\{$class}";
                $class = new $class($response, $item);

                $result = $class->parse();

                if ($result !== false) {
                    return $result;
                }
            }
        }

        return false;
    }

    /**
     * Merge the ^ continue responses to the last - response.
     *
     * @param Collection<ResponseQueueItem> $responses The array containing the responses.
     *
     * @return Collection<ResponseQueueItem>
     */
    protected function concatContinues(Collection $responses): Collection
    {
        $lastData = $responses->first();
        $lastResponse = "";

        $continues = Collection::make($responses->all());
        $continues->each(
            function (ResponseQueueItem $data, $response) use (&$lastData, &$lastResponse, &$continues) {

                if ($data->type === 'continue') {
                    $continues->remove($lastResponse);
                    $continues->remove($response);

                    /**
                     * none -- the default, nothing is added when continuation lines are joined together.
                     * space -- continuation lines are joined by a space character (\s)
                     * newline -- continuation lines are joined by a line break character (\n)
                     */
                    $options = $lastData->options;
                    $method = $options['concat'];

                    switch ($method) {
                        case 'space':
                            $lastResponse .= " {$response}";
                            break;

                        case 'newline':
                            $lastResponse .= "\n{$response}";
                            break;

                        case 'none':
                        default:
                            $lastResponse .= $response;
                            break;
                    }

                    $continues->put($lastResponse, $lastData);
                }

                if ($data->command !== '^') {
                    $lastData = $data;
                    $lastResponse = $response;
                }
            }
        );


        return $continues;
    }

    /**
     * Determine the order of responses by type.
     *
     * @param Collection<ResponseQueueItem> $responses The responses to inspect.
     *
     * @return Collection<ResponseQueueItem>
     */
    private function determineResponseOrder(Collection $responses): Collection
    {
        return $responses->each(
            function (ResponseQueueItem $data, $response) use ($responses) {
                if (isset($data->type)) {
                    switch ($data->type) {
                        case 'condition':
                            $data->order += 3000000;
                            break;
                        case 'weighted':
                        case 'atomic':
                            $data->order += 1000000;
                            break;
                    }

                    $responses->put($response, $data);
                }
            }
        );
    }

    /**
     * Determine the response type.
     *
     * @param string $response
     *
     * @return string
     */
    public function determineResponseType(string $response): string
    {
        $wildcards = [
            'weighted' => '{weight=(.+?)}',
            'condition' => '/^\*/',
            'continue' => '/^\^/',
            'atomic' => '/-/',
        ];

        foreach ($wildcards as $type => $pattern) {
            if (@preg_match_all($pattern, $response, $matches)) {
                return $type;
            }
        }

        return 'atomic';
    }

    /**
     * Process the Response Queue.
     *
     * @return false|int|string|null
     */
    public function process()
    {
        $sortedResponses = $this->determineResponseOrder($this->responses);

        $validResponses = new Collection([]);
        foreach ($sortedResponses as $response => $item) {
            $result = $this->validateResponse($response, $item);

            if ($result !== false) {
                $validResponses->put($result, $item);
            }
        }

        $validResponses = $this->concatContinues($validResponses);
        $validResponses = $this->sortResponses($validResponses);

        if ($validResponses->count() > 0) {
            return $validResponses->keys()->first();
        }

        return false;
    }
}


1			<?php
2			/*
3			* This file is part of Rivescript-php
4			*
5			* (c) Johnny Mast <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Axiom\Rivescript\Cortex\ResponseQueue;
12
13			use Axiom\Collections\Collection;
14			use Axiom\Rivescript\Cortex\Node;
15			use Axiom\Rivescript\Traits\Tags;
16
17			/**
18			* ResponseQueue class
19			*
20			* The ResponseQueue releases the responses in order of sending them
21			* back to the user.
22			*
23			* PHP version 7.4 and higher.
24			*
25			* @category Core
26			* @package Cortext\ResponseQueue
27			* @author Johnny Mast <[email protected]>
28			* @license https://opensource.org/licenses/MIT MIT
29			* @link https://github.com/axiom-labs/rivescript-php
30			* @since 0.4.0
31			*/
32			class ResponseQueue extends Collection
33			{
34
35			use Tags;
			0 ignored issues – show introduced 2022-01-14 18:49 UTC by Report Bug Copy Issue Report The trait `Axiom\Rivescript\Traits\Tags` requires some properties which are not provided by `Axiom\Rivescript\Cortex\...onseQueue\ResponseQueue`: `$memory`, `$input` Loading history...
36
37			/**
38			* A container with responses.
39			*
40			* @var Collection<ResponseQueueItem>
41			*/
42			protected Collection $responses;
43
44			/**
45			* Store the local interpreter options
46			* for this instance in time (since they can change).
47			*
48			* @var array<string, string>
49			*/
50			protected array $options = [];
51
52			/**
53			* The trigger string this ResponseQueue belongs to.
54			*
55			* @var string
56			*/
57			protected string $trigger = "";
58
59			/**
60			* ResponseQueue constructor.
61			*
62			* @param string $trigger the trigger this queue belongs to.
63			*/
64			public function __construct(string $trigger = "")
65			{
66			parent::__construct();
67
68			$this->responses = new Collection([]);
69			$this->trigger = $trigger;
70
71			$this->options = synapse()->memory->local()->all();
72			}
73
74			/**
75			* Attach a response to the queue.
76			*
77			* @param Node $node The node contains information about the command.
78			*
79			* @return void
80			*/
81			public function attach(Node $node): void
82			{
83			$type = $this->determineResponseType($node->source());
84			$queueItem = new ResponseQueueItem($node->command(), $type, 0, $this->options);
85			$this->responses->put($node->value(), $queueItem);
86			}
87
88			/**
89			* Sort the responses by order.
90			*
91			* @param Collection<ResponseQueueItem> $responses The array containing the resources.
92			*
93			* @return Collection<ResponseQueueItem>
94			*/
95			private function sortResponses(Collection $responses): Collection
96			{
97			return $responses->sort(
98			function ($current, $previous) {
99			return ($current->order < $previous->order) ? -1 : 1;
100			}
101			)->reverse();
102			}
103
104			/**
105			* Check if a response is allowed to be returned by the bot or not.
106			*
107			* @param string $response The response to validate.
108			* @param ResponseQueueItem $item The ResponseQueueItem.
109			*
110			* @return false\|mixed
111			*/
112			private function validateResponse(string $response, ResponseQueueItem $item)
113			{
114			$response = $this->parseTags($response);
115			$responses = synapse()->responses;
116
117			foreach ($responses as $class) {
118			if (class_exists("\\Axiom\\Rivescript\\Cortex\\Responses\\{$class}")) {
119			$class = "\\Axiom\\Rivescript\\Cortex\\Responses\\{$class}";
120			$class = new $class($response, $item);
121
122			$result = $class->parse();
123
124			if ($result !== false) {
125			return $result;
126			}
127			}
128			}
129
130			return false;
131			}
132
133			/**
134			* Merge the ^ continue responses to the last - response.
135			*
136			* @param Collection<ResponseQueueItem> $responses The array containing the responses.
137			*
138			* @return Collection<ResponseQueueItem>
139			*/
140			protected function concatContinues(Collection $responses): Collection
141			{
142			$lastData = $responses->first();
143			$lastResponse = "";
144
145			$continues = Collection::make($responses->all());
146			$continues->each(
147			function (ResponseQueueItem $data, $response) use (&$lastData, &$lastResponse, &$continues) {
148
149			if ($data->type === 'continue') {
150			$continues->remove($lastResponse);
151			$continues->remove($response);
152
153			/**
154			* none -- the default, nothing is added when continuation lines are joined together.
155			* space -- continuation lines are joined by a space character (\s)
156			* newline -- continuation lines are joined by a line break character (\n)
157			*/
158			$options = $lastData->options;
159			$method = $options['concat'];
160
161			switch ($method) {
162			case 'space':
163			$lastResponse .= " {$response}";
164			break;
165
166			case 'newline':
167			$lastResponse .= "\n{$response}";
168			break;
169
170			case 'none':
171			default:
172			$lastResponse .= $response;
173			break;
174			}
175
176			$continues->put($lastResponse, $lastData);
177			}
178
179			if ($data->command !== '^') {
180			$lastData = $data;
181			$lastResponse = $response;
182			}
183			}
184			);
185
186
187			return $continues;
188			}
189
190			/**
191			* Determine the order of responses by type.
192			*
193			* @param Collection<ResponseQueueItem> $responses The responses to inspect.
194			*
195			* @return Collection<ResponseQueueItem>
196			*/
197			private function determineResponseOrder(Collection $responses): Collection
198			{
199			return $responses->each(
200			function (ResponseQueueItem $data, $response) use ($responses) {
201			if (isset($data->type)) {
202			switch ($data->type) {
203			case 'condition':
204			$data->order += 3000000;
205			break;
206			case 'weighted':
207			case 'atomic':
208			$data->order += 1000000;
209			break;
210			}
211
212			$responses->put($response, $data);
213			}
214			}
215			);
216			}
217
218			/**
219			* Determine the response type.
220			*
221			* @param string $response
222			*
223			* @return string
224			*/
225			public function determineResponseType(string $response): string
226			{
227			$wildcards = [
228			'weighted' => '{weight=(.+?)}',
229			'condition' => '/^\*/',
230			'continue' => '/^\^/',
231			'atomic' => '/-/',
232			];
233
234			foreach ($wildcards as $type => $pattern) {
235			if (@preg_match_all($pattern, $response, $matches)) {
236			return $type;
237			}
238			}
239
240			return 'atomic';
241			}
242
243			/**
244			* Process the Response Queue.
245			*
246			* @return false\|int\|string\|null
247			*/
248			public function process()
249			{
250			$sortedResponses = $this->determineResponseOrder($this->responses);
251
252			$validResponses = new Collection([]);
253			foreach ($sortedResponses as $response => $item) {
254			$result = $this->validateResponse($response, $item);
255
256			if ($result !== false) {
257			$validResponses->put($result, $item);
258			}
259			}
260
261			$validResponses = $this->concatContinues($validResponses);
262			$validResponses = $this->sortResponses($validResponses);
263
264			if ($validResponses->count() > 0) {
265			return $validResponses->keys()->first();
266			}
267
268			return false;
269			}
270			}
271

johnnymast / rivescript-php

Push — master ( ff7261...4233f0 )

ResponseQueue::concatContinues() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like