MatchBuilder::before() - Code Metrics - Inspection of "Add support for PHP 8" - FoolCode/SphinxQL-Query-Builder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#197)

unknown

created 2021-02-10 12:39 UTC

MatchBuilder::before() A

↳ Parent: MatchBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php

namespace Foolz\SphinxQL;

use Closure;

/**
 * Query Builder class for MatchBuilder statements.
 */
class MatchBuilder
{
	/**
	 * The last compiled query.
	 *
	 * @var string
	 */
	protected $last_compiled;

	/**
	 * List of match operations.
	 *
	 * @var array
	 */
	protected $tokens = array();

	/**
	 * The owning SphinxQL object; used for escaping text.
	 *
	 * @var SphinxQL
	 */
	protected $sphinxql;

	/**
	 * @param SphinxQL $sphinxql
	 */
	public function __construct(SphinxQL $sphinxql)
	{
		$this->sphinxql = $sphinxql;
	}

	/**
	 * Match text or sub expression.
	 *
	 * Examples:
	 *    $match->match('test');
	 *    // test
	 *
	 *    $match->match('test case');
	 *    // (test case)
	 *
	 *    $match->match(function ($m) {
	 *        $m->match('a')->orMatch('b');
	 *    });
	 *    // (a | b)
	 *
	 *    $sub = new MatchBuilder($sphinxql);
	 *    $sub->match('a')->orMatch('b');
	 *    $match->match($sub);
	 *    // (a | b)
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression to match.
	 *
	 * @return $this
	 */
	public function match($keywords = null): self
	{
		if ($keywords !== null) {
			$this->tokens[] = array('MATCH' => $keywords);
		}

		return $this;
	}

	/**
	 * Provide an alternation match.
	 *
	 * Examples:
	 *    $match->match('test')->orMatch();
	 *    // test |
	 *
	 *    $match->match('test')->orMatch('case');
	 *    // test | case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression to alternatively match.
	 *
	 * @return $this
	 */
	public function orMatch($keywords = null): self
	{
		$this->tokens[] = array('OPERATOR' => '| ');
		$this->match($keywords);

		return $this;
	}

	/**
	 * Provide an optional match.
	 *
	 * Examples:
	 *    $match->match('test')->maybe();
	 *    // test MAYBE
	 *
	 *    $match->match('test')->maybe('case');
	 *    // test MAYBE case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression to optionally match.
	 *
	 * @return $this
	 */
	public function maybe($keywords = null): self
	{
		$this->tokens[] = array('OPERATOR' => 'MAYBE ');
		$this->match($keywords);

		return $this;
	}

	/**
	 * Do not match a keyword.
	 *
	 * Examples:
	 *    $match->not()->match('test');
	 *    // -test
	 *
	 *    $match->not('test');
	 *    // -test
	 *
	 * @param string|MatchBuilder|\Closure $keyword The word not to match.
	 *
	 * @return $this
	 */
	public function not($keyword = null): self
	{
		$this->tokens[] = array('OPERATOR' => '-');
		$this->match($keyword);

		return $this;
	}

	/**
	 * Specify which field(s) to search.
	 *
	 * Examples:
	 *    $match->field('*')->match('test');
	 *    // @* test
	 *
	 *    $match->field('title')->match('test');
	 *    // @title test
	 *
	 *    $match->field('body', 50)->match('test');
	 *    // @body[50] test
	 *
	 *    $match->field('title', 'body')->match('test');
	 *    // @(title,body) test
	 *
	 *    $match->field(['title', 'body'])->match('test');
	 *    // @(title,body) test
	 *
	 *    $match->field('@relaxed')->field('nosuchfield')->match('test');
	 *    // @@relaxed @nosuchfield test
	 *
	 * @param string|array $fields Field or fields to search.
	 * @param int          $limit  Maximum position limit in field a match is allowed at.
	 *
	 * @return $this
	 */
	public function field($fields, $limit = null): self
	{
		if (is_string($fields)) {
			$fields = func_get_args();
			$limit = null;
		}
		if (!is_string(end($fields))) {
			$limit = array_pop($fields);
		}
		$this->tokens[] = array(
			'FIELD'  => '@',
			'fields' => $fields,
			'limit'  => $limit,
		);

		return $this;
	}

	/**
	 * Specify which field(s) not to search.
	 *
	 * Examples:
	 *    $match->ignoreField('title')->match('test');
	 *    // @!title test
	 *
	 *    $match->ignoreField('title', 'body')->match('test');
	 *    // @!(title,body) test
	 *
	 *    $match->ignoreField(['title', 'body'])->match('test');
	 *    // @!(title,body) test
	 *
	 * @param string|array $fields Field or fields to ignore during search.
	 *
	 * @return $this
	 */
	public function ignoreField($fields): self
	{
		if (is_string($fields)) {
			$fields = func_get_args();
		}
		$this->tokens[] = array(
			'FIELD'  => '@!',
			'fields' => $fields,
			'limit'  => null,
		);

		return $this;
	}

	/**
	 * Match an exact phrase.
	 *
	 * Example:
	 *    $match->phrase('test case');
	 *    // "test case"
	 *
	 * @param string $keywords The phrase to match.
	 *
	 * @return $this
	 */
	public function phrase($keywords): self
	{
		$this->tokens[] = array('PHRASE' => $keywords);

		return $this;
	}

	/**
	 * Provide an optional phrase.
	 *
	 * Example:
	 *    $match->phrase('test case')->orPhrase('another case');
	 *    // "test case" | "another case"
	 *
	 * @param string $keywords The phrase to match.
	 *
	 * @return $this
	 */
	public function orPhrase($keywords): self
	{
		$this->tokens[] = array('OPERATOR' => '| ');
		$this->phrase($keywords);

		return $this;
	}

	/**
	 * Match if keywords are close enough.
	 *
	 * Example:
	 *    $match->proximity('test case', 5);
	 *    // "test case"~5
	 *
	 * @param string $keywords The words to match.
	 * @param int    $distance The upper limit on separation between words.
	 *
	 * @return $this
	 */
	public function proximity($keywords, $distance): self
	{
		$this->tokens[] = array(
			'PROXIMITY' => $distance,
			'keywords'  => $keywords,
		);

		return $this;
	}

	/**
	 * Match if enough keywords are present.
	 *
	 * Examples:
	 *    $match->quorum('this is a test case', 3);
	 *    // "this is a test case"/3
	 *
	 *    $match->quorum('this is a test case', 0.5);
	 *    // "this is a test case"/0.5
	 *
	 * @param string    $keywords  The words to match.
	 * @param int|float $threshold The minimum number or percent of words that must match.
	 *
	 * @return $this
	 */
	public function quorum($keywords, $threshold): self
	{
		$this->tokens[] = array(
			'QUORUM'   => $threshold,
			'keywords' => $keywords,
		);

		return $this;
	}

	/**
	 * Assert keywords or expressions must be matched in order.
	 *
	 * Examples:
	 *    $match->match('test')->before();
	 *    // test <<
	 *
	 *    $match->match('test')->before('case');
	 *    // test << case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression that must come after.
	 *
	 * @return $this
	 */
	public function before($keywords = null): self
	{
		$this->tokens[] = array('OPERATOR' => '<< ');
		$this->match($keywords);

		return $this;
	}

	/**
	 * Assert a keyword must be matched exactly as written.
	 *
	 * Examples:
	 *    $match->match('test')->exact('cases');
	 *    // test =cases
	 *
	 *    $match->match('test')->exact()->phrase('specific cases');
	 *    // test ="specific cases"
	 *
	 * @param string $keyword The word that must be matched exactly.
	 *
	 * @return $this
	 */
	public function exact($keyword = null): self
	{
		$this->tokens[] = array('OPERATOR' => '=');
		$this->match($keyword);

		return $this;
	}

	/**
	 * Boost the IDF score of a keyword.
	 *
	 * Examples:
	 *    $match->match('test')->boost(1.2);
	 *    // test^1.2
	 *
	 *    $match->match('test')->boost('case', 1.2);
	 *    // test case^1.2
	 *
	 * @param string $keyword The word to modify the score of.
	 * @param float  $amount  The amount to boost the score.
	 *
	 * @return $this
	 */
	public function boost($keyword, $amount = null): self
	{
		if ($amount === null) {
			$amount = $keyword;
		} else {
			$this->match($keyword);
		}
		$this->tokens[] = array('BOOST' => $amount);

		return $this;
	}

	/**
	 * Assert keywords or expressions must be matched close to each other.
	 *
	 * Examples:
	 *    $match->match('test')->near(3);
	 *    // test NEAR/3
	 *
	 *    $match->match('test')->near('case', 3);
	 *    // test NEAR/3 case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression to match nearby.
	 * @param int                   $distance Maximum distance to the match.
	 *
	 * @return $this
	 */
	public function near($keywords, $distance = null): self
	{
		$this->tokens[] = array('NEAR' => $distance ?: $keywords);
		if ($distance !== null) {
			$this->match($keywords);
		}

		return $this;
	}

	/**
	 * Assert matches must be in the same sentence.
	 *
	 * Examples:
	 *    $match->match('test')->sentence();
	 *    // test SENTENCE
	 *
	 *    $match->match('test')->sentence('case');
	 *    // test SENTENCE case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in the sentence.
	 *
	 * @return $this
	 */
	public function sentence($keywords = null): self
	{
		$this->tokens[] = array('OPERATOR' => 'SENTENCE ');
		$this->match($keywords);

		return $this;
	}

	/**
	 * Assert matches must be in the same paragraph.
	 *
	 * Examples:
	 *    $match->match('test')->paragraph();
	 *    // test PARAGRAPH
	 *
	 *    $match->match('test')->paragraph('case');
	 *    // test PARAGRAPH case
	 *
	 * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in the paragraph.
	 *
	 * @return $this
	 */
	public function paragraph($keywords = null): self
	{
		$this->tokens[] = array('OPERATOR' => 'PARAGRAPH ');
		$this->match($keywords);

		return $this;
	}

	/**
	 * Assert matches must be in the specified zone(s).
	 *
	 * Examples:
	 *    $match->zone('th');
	 *    // ZONE:(th)
	 *
	 *    $match->zone(['h3', 'h4']);
	 *    // ZONE:(h3,h4)
	 *
	 *    $match->zone('th', 'test');
	 *    // ZONE:(th) test
	 *
	 * @param string|array          $zones    The zone or zones to search.
	 * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in these zones.
	 *
	 * @return $this
	 */
	public function zone($zones, $keywords = null): self
	{
		if (is_string($zones)) {
			$zones = array($zones);
		}
		$this->tokens[] = array('ZONE' => $zones);
		$this->match($keywords);

		return $this;
	}


	/**
	 * Assert matches must be in the same instance of the specified zone.
	 *
	 * Examples:
	 *    $match->zonespan('th');
	 *    // ZONESPAN:(th)
	 *
	 *    $match->zonespan('th', 'test');
	 *    // ZONESPAN:(th) test
	 *
	 * @param string                $zone     The zone to search.
	 * @param string|MatchBuilder|\Closure $keywords The text or expression that must be in this zone.
	 *
	 * @return $this
	 */
	public function zonespan($zone, $keywords = null): self
	{
		$this->tokens[] = array('ZONESPAN' => $zone);
		$this->match($keywords);

		return $this;
	}

	/**
	 * Build the match expression.
	 * @return $this
	 */
	public function compile(): self
	{
		$query = '';

		foreach ($this->tokens as $token) {
			$tokenKey = key($token);

			switch ($tokenKey) {
				case 'MATCH':{
					$query .= $this->compileMatch($token['MATCH']);
					break;
				}
				case 'OPERATOR':{
					$query .= $token['OPERATOR'];
					break;
				}
				case 'FIELD':{
					$query .= $this->compileField($token['FIELD'],$token['fields'],$token['limit']);
					break;
				}
				case 'PHRASE':{
					$query .= '"'.$this->sphinxql->escapeMatch($token['PHRASE']).'" ';
					break;
				}
				case 'PROXIMITY':{
					$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"~';
					$query .= $token['PROXIMITY'].' ';
					break;
				}
				case 'QUORUM':{
					$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"/';
					$query .= $token['QUORUM'].' ';
					break;
				}
				case 'BOOST':{
					$query = rtrim($query).'^'.$token['BOOST'].' ';
					break;
				}
				case 'NEAR':{
					$query .= 'NEAR/'.$token['NEAR'].' ';
					break;
				}
				case 'ZONE':{
					$query .= 'ZONE:('.implode(',', $token['ZONE']).') ';
					break;
				}
				case 'ZONESPAN':{
					$query .= 'ZONESPAN:('.$token['ZONESPAN'].') ';
					break;
				}
			}
		}

		$this->last_compiled = trim($query);

		return $this;
	}

	private function compileMatch($token): string{
		if ($token instanceof Expression) {
			return $token->value().' ';
		}
		if ($token instanceof self) {
			return '('.$token->compile()->getCompiled().') ';
		}
		if ($token instanceof Closure) {
			$sub = new static($this->sphinxql);
			$token($sub);
			return '('.$sub->compile()->getCompiled().') ';
		}
		if (strpos($token, ' ') === false) {
			return $this->sphinxql->escapeMatch($token).' ';
		}
		return '('.$this->sphinxql->escapeMatch($token).') ';
	}

	private function compileField($token,$fields,$limit): string{
		$query = $token;

		if (count($fields) === 1) {
			$query .= $fields[0];
		} else {
			$query .= '('.implode(',', $fields).')';
		}
		if ($limit) {
			$query .= '['.$limit.']';
		}
		$query .= ' ';

		return $query;
	}

	/**
	 * Returns the latest compiled match expression.
	 *
	 * @return string The last compiled match expression.
	 */
	public function getCompiled(): string
	{
		return $this->last_compiled;
	}
}


1			<?php
2
3			namespace Foolz\SphinxQL;
4
5			use Closure;
6
7			/**
8			* Query Builder class for MatchBuilder statements.
9			*/
10			class MatchBuilder
11			{
12			/**
13			* The last compiled query.
14			*
15			* @var string
16			*/
17			protected $last_compiled;
18
19			/**
20			* List of match operations.
21			*
22			* @var array
23			*/
24			protected $tokens = array();
25
26			/**
27			* The owning SphinxQL object; used for escaping text.
28			*
29			* @var SphinxQL
30			*/
31			protected $sphinxql;
32
33			/**
34			* @param SphinxQL $sphinxql
35			*/
36			public function __construct(SphinxQL $sphinxql)
37			{
38			$this->sphinxql = $sphinxql;
39			}
40
41			/**
42			* Match text or sub expression.
43			*
44			* Examples:
45			* $match->match('test');
46			* // test
47			*
48			* $match->match('test case');
49			* // (test case)
50			*
51			* $match->match(function ($m) {
52			* $m->match('a')->orMatch('b');
53			* });
54			* // (a \| b)
55			*
56			* $sub = new MatchBuilder($sphinxql);
57			* $sub->match('a')->orMatch('b');
58			* $match->match($sub);
59			* // (a \| b)
60			*
61			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to match.
62			*
63			* @return $this
64			*/
65			public function match($keywords = null): self
66			{
67			if ($keywords !== null) {
68			$this->tokens[] = array('MATCH' => $keywords);
69			}
70
71			return $this;
72			}
73
74			/**
75			* Provide an alternation match.
76			*
77			* Examples:
78			* $match->match('test')->orMatch();
79			* // test \|
80			*
81			* $match->match('test')->orMatch('case');
82			* // test \| case
83			*
84			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to alternatively match.
85			*
86			* @return $this
87			*/
88			public function orMatch($keywords = null): self
89			{
90			$this->tokens[] = array('OPERATOR' => '\| ');
91			$this->match($keywords);
92
93			return $this;
94			}
95
96			/**
97			* Provide an optional match.
98			*
99			* Examples:
100			* $match->match('test')->maybe();
101			* // test MAYBE
102			*
103			* $match->match('test')->maybe('case');
104			* // test MAYBE case
105			*
106			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to optionally match.
107			*
108			* @return $this
109			*/
110			public function maybe($keywords = null): self
111			{
112			$this->tokens[] = array('OPERATOR' => 'MAYBE ');
113			$this->match($keywords);
114
115			return $this;
116			}
117
118			/**
119			* Do not match a keyword.
120			*
121			* Examples:
122			* $match->not()->match('test');
123			* // -test
124			*
125			* $match->not('test');
126			* // -test
127			*
128			* @param string\|MatchBuilder\|\Closure $keyword The word not to match.
129			*
130			* @return $this
131			*/
132			public function not($keyword = null): self
133			{
134			$this->tokens[] = array('OPERATOR' => '-');
135			$this->match($keyword);
136
137			return $this;
138			}
139
140			/**
141			* Specify which field(s) to search.
142			*
143			* Examples:
144			* $match->field('*')->match('test');
145			* // @* test
146			*
147			* $match->field('title')->match('test');
148			* // @title test
149			*
150			* $match->field('body', 50)->match('test');
151			* // @body[50] test
152			*
153			* $match->field('title', 'body')->match('test');
154			* // @(title,body) test
155			*
156			* $match->field(['title', 'body'])->match('test');
157			* // @(title,body) test
158			*
159			* $match->field('@relaxed')->field('nosuchfield')->match('test');
160			* // @@relaxed @nosuchfield test
161			*
162			* @param string\|array $fields Field or fields to search.
163			* @param int $limit Maximum position limit in field a match is allowed at.
164			*
165			* @return $this
166			*/
167			public function field($fields, $limit = null): self
168			{
169			if (is_string($fields)) {
170			$fields = func_get_args();
171			$limit = null;
172			}
173			if (!is_string(end($fields))) {
174			$limit = array_pop($fields);
175			}
176			$this->tokens[] = array(
177			'FIELD' => '@',
178			'fields' => $fields,
179			'limit' => $limit,
180			);
181
182			return $this;
183			}
184
185			/**
186			* Specify which field(s) not to search.
187			*
188			* Examples:
189			* $match->ignoreField('title')->match('test');
190			* // @!title test
191			*
192			* $match->ignoreField('title', 'body')->match('test');
193			* // @!(title,body) test
194			*
195			* $match->ignoreField(['title', 'body'])->match('test');
196			* // @!(title,body) test
197			*
198			* @param string\|array $fields Field or fields to ignore during search.
199			*
200			* @return $this
201			*/
202			public function ignoreField($fields): self
203			{
204			if (is_string($fields)) {
205			$fields = func_get_args();
206			}
207			$this->tokens[] = array(
208			'FIELD' => '@!',
209			'fields' => $fields,
210			'limit' => null,
211			);
212
213			return $this;
214			}
215
216			/**
217			* Match an exact phrase.
218			*
219			* Example:
220			* $match->phrase('test case');
221			* // "test case"
222			*
223			* @param string $keywords The phrase to match.
224			*
225			* @return $this
226			*/
227			public function phrase($keywords): self
228			{
229			$this->tokens[] = array('PHRASE' => $keywords);
230
231			return $this;
232			}
233
234			/**
235			* Provide an optional phrase.
236			*
237			* Example:
238			* $match->phrase('test case')->orPhrase('another case');
239			* // "test case" \| "another case"
240			*
241			* @param string $keywords The phrase to match.
242			*
243			* @return $this
244			*/
245			public function orPhrase($keywords): self
246			{
247			$this->tokens[] = array('OPERATOR' => '\| ');
248			$this->phrase($keywords);
249
250			return $this;
251			}
252
253			/**
254			* Match if keywords are close enough.
255			*
256			* Example:
257			* $match->proximity('test case', 5);
258			* // "test case"~5
259			*
260			* @param string $keywords The words to match.
261			* @param int $distance The upper limit on separation between words.
262			*
263			* @return $this
264			*/
265			public function proximity($keywords, $distance): self
266			{
267			$this->tokens[] = array(
268			'PROXIMITY' => $distance,
269			'keywords' => $keywords,
270			);
271
272			return $this;
273			}
274
275			/**
276			* Match if enough keywords are present.
277			*
278			* Examples:
279			* $match->quorum('this is a test case', 3);
280			* // "this is a test case"/3
281			*
282			* $match->quorum('this is a test case', 0.5);
283			* // "this is a test case"/0.5
284			*
285			* @param string $keywords The words to match.
286			* @param int\|float $threshold The minimum number or percent of words that must match.
287			*
288			* @return $this
289			*/
290			public function quorum($keywords, $threshold): self
291			{
292			$this->tokens[] = array(
293			'QUORUM' => $threshold,
294			'keywords' => $keywords,
295			);
296
297			return $this;
298			}
299
300			/**
301			* Assert keywords or expressions must be matched in order.
302			*
303			* Examples:
304			* $match->match('test')->before();
305			* // test <<
306			*
307			* $match->match('test')->before('case');
308			* // test << case
309			*
310			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must come after.
311			*
312			* @return $this
313			*/
314			public function before($keywords = null): self
315			{
316			$this->tokens[] = array('OPERATOR' => '<< ');
317			$this->match($keywords);
318
319			return $this;
320			}
321
322			/**
323			* Assert a keyword must be matched exactly as written.
324			*
325			* Examples:
326			* $match->match('test')->exact('cases');
327			* // test =cases
328			*
329			* $match->match('test')->exact()->phrase('specific cases');
330			* // test ="specific cases"
331			*
332			* @param string $keyword The word that must be matched exactly.
333			*
334			* @return $this
335			*/
336			public function exact($keyword = null): self
337			{
338			$this->tokens[] = array('OPERATOR' => '=');
339			$this->match($keyword);
340
341			return $this;
342			}
343
344			/**
345			* Boost the IDF score of a keyword.
346			*
347			* Examples:
348			* $match->match('test')->boost(1.2);
349			* // test^1.2
350			*
351			* $match->match('test')->boost('case', 1.2);
352			* // test case^1.2
353			*
354			* @param string $keyword The word to modify the score of.
355			* @param float $amount The amount to boost the score.
356			*
357			* @return $this
358			*/
359			public function boost($keyword, $amount = null): self
360			{
361			if ($amount === null) {
362			$amount = $keyword;
363			} else {
364			$this->match($keyword);
365			}
366			$this->tokens[] = array('BOOST' => $amount);
367
368			return $this;
369			}
370
371			/**
372			* Assert keywords or expressions must be matched close to each other.
373			*
374			* Examples:
375			* $match->match('test')->near(3);
376			* // test NEAR/3
377			*
378			* $match->match('test')->near('case', 3);
379			* // test NEAR/3 case
380			*
381			* @param string\|MatchBuilder\|\Closure $keywords The text or expression to match nearby.
382			* @param int $distance Maximum distance to the match.
383			*
384			* @return $this
385			*/
386			public function near($keywords, $distance = null): self
387			{
388			$this->tokens[] = array('NEAR' => $distance ?: $keywords);
389			if ($distance !== null) {
390			$this->match($keywords);
391			}
392
393			return $this;
394			}
395
396			/**
397			* Assert matches must be in the same sentence.
398			*
399			* Examples:
400			* $match->match('test')->sentence();
401			* // test SENTENCE
402			*
403			* $match->match('test')->sentence('case');
404			* // test SENTENCE case
405			*
406			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in the sentence.
407			*
408			* @return $this
409			*/
410			public function sentence($keywords = null): self
411			{
412			$this->tokens[] = array('OPERATOR' => 'SENTENCE ');
413			$this->match($keywords);
414
415			return $this;
416			}
417
418			/**
419			* Assert matches must be in the same paragraph.
420			*
421			* Examples:
422			* $match->match('test')->paragraph();
423			* // test PARAGRAPH
424			*
425			* $match->match('test')->paragraph('case');
426			* // test PARAGRAPH case
427			*
428			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in the paragraph.
429			*
430			* @return $this
431			*/
432			public function paragraph($keywords = null): self
433			{
434			$this->tokens[] = array('OPERATOR' => 'PARAGRAPH ');
435			$this->match($keywords);
436
437			return $this;
438			}
439
440			/**
441			* Assert matches must be in the specified zone(s).
442			*
443			* Examples:
444			* $match->zone('th');
445			* // ZONE:(th)
446			*
447			* $match->zone(['h3', 'h4']);
448			* // ZONE:(h3,h4)
449			*
450			* $match->zone('th', 'test');
451			* // ZONE:(th) test
452			*
453			* @param string\|array $zones The zone or zones to search.
454			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in these zones.
455			*
456			* @return $this
457			*/
458			public function zone($zones, $keywords = null): self
459			{
460			if (is_string($zones)) {
461			$zones = array($zones);
462			}
463			$this->tokens[] = array('ZONE' => $zones);
464			$this->match($keywords);
465
466			return $this;
467			}
468
469
470			/**
471			* Assert matches must be in the same instance of the specified zone.
472			*
473			* Examples:
474			* $match->zonespan('th');
475			* // ZONESPAN:(th)
476			*
477			* $match->zonespan('th', 'test');
478			* // ZONESPAN:(th) test
479			*
480			* @param string $zone The zone to search.
481			* @param string\|MatchBuilder\|\Closure $keywords The text or expression that must be in this zone.
482			*
483			* @return $this
484			*/
485			public function zonespan($zone, $keywords = null): self
486			{
487			$this->tokens[] = array('ZONESPAN' => $zone);
488			$this->match($keywords);
489
490			return $this;
491			}
492
493			/**
494			* Build the match expression.
495			* @return $this
496			*/
497			public function compile(): self
498			{
499			$query = '';
500
501			foreach ($this->tokens as $token) {
502			$tokenKey = key($token);
503
504			switch ($tokenKey) {
505			case 'MATCH':{
506			$query .= $this->compileMatch($token['MATCH']);
507			break;
508			}
509			case 'OPERATOR':{
510			$query .= $token['OPERATOR'];
511			break;
512			}
513			case 'FIELD':{
514			$query .= $this->compileField($token['FIELD'],$token['fields'],$token['limit']);
515			break;
516			}
517			case 'PHRASE':{
518			$query .= '"'.$this->sphinxql->escapeMatch($token['PHRASE']).'" ';
519			break;
520			}
521			case 'PROXIMITY':{
522			$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"~';
523			$query .= $token['PROXIMITY'].' ';
524			break;
525			}
526			case 'QUORUM':{
527			$query .= '"'.$this->sphinxql->escapeMatch($token['keywords']).'"/';
528			$query .= $token['QUORUM'].' ';
529			break;
530			}
531			case 'BOOST':{
532			$query = rtrim($query).'^'.$token['BOOST'].' ';
533			break;
534			}
535			case 'NEAR':{
536			$query .= 'NEAR/'.$token['NEAR'].' ';
537			break;
538			}
539			case 'ZONE':{
540			$query .= 'ZONE:('.implode(',', $token['ZONE']).') ';
541			break;
542			}
543			case 'ZONESPAN':{
544			$query .= 'ZONESPAN:('.$token['ZONESPAN'].') ';
545			break;
546			}
547			}
548			}
549
550			$this->last_compiled = trim($query);
551
552			return $this;
553			}
554
555			private function compileMatch($token): string{
556			if ($token instanceof Expression) {
557			return $token->value().' ';
558			}
559			if ($token instanceof self) {
560			return '('.$token->compile()->getCompiled().') ';
561			}
562			if ($token instanceof Closure) {
563			$sub = new static($this->sphinxql);
564			$token($sub);
565			return '('.$sub->compile()->getCompiled().') ';
566			}
567			if (strpos($token, ' ') === false) {
568			return $this->sphinxql->escapeMatch($token).' ';
569			}
570			return '('.$this->sphinxql->escapeMatch($token).') ';
571			}
572
573			private function compileField($token,$fields,$limit): string{
574			$query = $token;
575
576			if (count($fields) === 1) {
577			$query .= $fields[0];
578			} else {
579			$query .= '('.implode(',', $fields).')';
580			}
581			if ($limit) {
582			$query .= '['.$limit.']';
583			}
584			$query .= ' ';
585
586			return $query;
587			}
588
589			/**
590			* Returns the latest compiled match expression.
591			*
592			* @return string The last compiled match expression.
593			*/
594			public function getCompiled(): string
595			{
596			return $this->last_compiled;
597			}
598			}
599

FoolCode / SphinxQL-Query-Builder

Pull Request — master (#197)

MatchBuilder::before() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like