WIP: Add ranges support

lib/Languages/Galach/Generators/Native/Range.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace QueryTranslator\Languages\Galach\Generators\Native;
+
+use LogicException;
+use QueryTranslator\Languages\Galach\Generators\Common\Visitor;
+use QueryTranslator\Languages\Galach\Values\Node\Term;
+use QueryTranslator\Languages\Galach\Values\Token\Range as RangeToken;
+use QueryTranslator\Values\Node;
+
+/**
+ * Range Node Visitor implementation.
+ */
+final class Range extends Visitor
+{
+    public function accept(Node $node)
+    {
+        return $node instanceof Term && $node->token instanceof RangeToken;
+    }
+
+    public function visit(Node $node, Visitor $subVisitor = null, $options = null)
+    {
+        if (!$node instanceof Term) {
+            throw new LogicException(
+                'Implementation accepts instance of Term Node'
+            );
+        }
+
+        $token = $node->token;
+
+        if (!$token instanceof RangeToken) {
+            throw new LogicException(
+                'Implementation accepts instance of Range Token'
+            );
+        }
+
+        $domainPrefix = '' === $token->domain ? '' : "{$token->domain}:";
+
+        switch ($token->type) {
+            case RangeToken::TYPE_INCLUSIVE:
+                return $domainPrefix . '[' . $token->rangeFrom . ' TO ' . $token->rangeTo . ']';
+
+            case RangeToken::TYPE_EXCLUSIVE:
+                return $domainPrefix . '{' . $token->rangeFrom . ' TO ' . $token->rangeTo . '}';
+
+            default:
+                throw new LogicException(sprintf('Range type %s is not supported', $token->type));
+        }
+    }
+}

lib/Languages/Galach/TokenExtractor/Full.php

@@ -5,6 +5,7 @@
 use QueryTranslator\Languages\Galach\TokenExtractor;
 use QueryTranslator\Languages\Galach\Tokenizer;
 use QueryTranslator\Languages\Galach\Values\Token\Phrase;
+use QueryTranslator\Languages\Galach\Values\Token\Range;
 use QueryTranslator\Languages\Galach\Values\Token\Tag;
 use QueryTranslator\Languages\Galach\Values\Token\User;
 use QueryTranslator\Languages\Galach\Values\Token\Word;
@@ -35,6 +36,7 @@ final class Full extends TokenExtractor
         '/(?<lexeme>(?:(?<marker>(?<!\\\\)\#)(?<tag>[a-zA-Z0-9_][a-zA-Z0-9_\-.]*)))(?:[\s"()+!]|$)/Au' => Tokenizer::TOKEN_TERM,
         '/(?<lexeme>(?:(?<marker>(?<!\\\\)@)(?<user>[a-zA-Z0-9_][a-zA-Z0-9_\-.]*)))(?:[\s"()+!]|$)/Au' => Tokenizer::TOKEN_TERM,
         '/(?<lexeme>(?:(?<domain>[a-zA-Z_][a-zA-Z0-9_\-.]*):)?(?<quote>(?<!\\\\)["])(?<phrase>.*?)(?:(?<!\\\\)(?P=quote)))/Aus' => Tokenizer::TOKEN_TERM,
+        '/(?<lexeme>(?:(?<domain>[a-zA-Z_][a-zA-Z0-9_\-.]*):)?(?<rangeStartSymbol>[\[\{])(?<rangeFrom>[a-zA-Z0-9]+) TO (?<rangeTo>[a-zA-Z0-9]+)[\]\}])/Aus' => Tokenizer::TOKEN_TERM,
         '/(?<lexeme>(?:(?<domain>[a-zA-Z_][a-zA-Z0-9_\-.]*):)?(?<word>(?:\\\\\\\\|\\\\ |\\\\\(|\\\\\)|\\\\"|[^"()\s])+?))(?:(?<!\\\\)["]|\(|\)|$|\s)/Au' => Tokenizer::TOKEN_TERM,
     ];
 
@@ -48,6 +50,14 @@ protected function createTermToken($position, array $data)
         $lexeme = $data['lexeme'];
 
         switch (true) {
+            case isset($data['rangeStartSymbol']):
+                return new Range(
+                    $lexeme,
+                    $position,
+                    $data['domain'],
+                    $data['rangeFrom'], $data['rangeTo'],
+                    Range::getTypeByStart($data['rangeStartSymbol'])
+                );
             case isset($data['word']):
                 return new Word(
                     $lexeme,

lib/Languages/Galach/Tokenizer.php

@@ -78,6 +78,7 @@ final class Tokenizer implements Tokenizing
      * @see \QueryTranslator\Languages\Galach\Values\Token\Tag
      * @see \QueryTranslator\Languages\Galach\Values\Token\User
      * @see \QueryTranslator\Languages\Galach\Values\Token\Word
+     * @see \QueryTranslator\Languages\Galach\Values\Token\Range
      */
     const TOKEN_TERM = 512;
 

lib/Languages/Galach/Values/Token/Range.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace QueryTranslator\Languages\Galach\Values\Token;
+
+use QueryTranslator\Languages\Galach\Tokenizer;
+use QueryTranslator\Values\Token;
+
+/**
+ * Range term token.
+ *
+ * @see \QueryTranslator\Languages\Galach\Tokenizer::TOKEN_TERM
+ */
+final class Range extends Token
+{
+    const TYPE_INCLUSIVE = 'inclusive';
+    const TYPE_EXCLUSIVE = 'exclusive';
+
+    /**
+     * Holds domain string.
+     *
+     * @var string
+     */
+    public $domain;
+
+    /**
+     * @var string
+     */
+    public $rangeFrom;
+
+    /**
+     * @var string
+     */
+    public $rangeTo;
+
+    /**
+     * @var string
+     */
+    public $type;
+
+    /**
+     * @param string $lexeme
+     * @param int    $position
+     * @param string $domain
+     * @param string $rangeFrom
+     * @param string $rangeTo
+     * @param string $type
+     */
+    public function __construct($lexeme, $position, $domain, $rangeFrom, $rangeTo, $type)
+    {
+        if (!in_array($type, [self::TYPE_EXCLUSIVE, self::TYPE_INCLUSIVE])) {
+            throw new \InvalidArgumentException(sprintf('Invalid range type: %s', $type));
+        }
+
+        parent::__construct(Tokenizer::TOKEN_TERM, $lexeme, $position);
+
+        $this->domain = $domain;
+        $this->rangeFrom = $rangeFrom;
+        $this->rangeTo = $rangeTo;
+        $this->type = $type;
+    }
+
+    /**
+     * Returns the range type, given the starting symbol.
+     *
+     * @param string $startSymbol the start symbol, either '[' or '{'
+     *
+     * @return string
+     */
+    public static function getTypeByStart($startSymbol)
+    {
+        if ('[' === $startSymbol) {
+            return self::TYPE_INCLUSIVE;
+        }
+
+        if ('{' === $startSymbol) {
+            return self::TYPE_EXCLUSIVE;
+        }
+
+        throw new \InvalidArgumentException(sprintf('Invalid range start symbol: %s', $startSymbol));
+    }
+}

tests/Galach/Generators/Native/RangeTest.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace QueryTranslator\Tests\Galach\Generators\Native;
+
+use PHPUnit\Framework\TestCase;
+use QueryTranslator\Languages\Galach\Generators\Common\Visitor;
+use QueryTranslator\Languages\Galach\Generators\Native\Range;
+use QueryTranslator\Languages\Galach\Values\Node\Mandatory;
+use QueryTranslator\Languages\Galach\Values\Node\Term;
+use QueryTranslator\Languages\Galach\Values\Token\Range as RangeToken;
+use QueryTranslator\Languages\Galach\Values\Token\Word;
+use QueryTranslator\Values\Node;
+
+class RangeTest extends TestCase
+{
+    /**
+     * @var Visitor
+     */
+    public $visitor;
+
+    protected function setUp()
+    {
+        $this->visitor = new Range();
+    }
+
+    public function acceptDataprovider()
+    {
+        return [
+            [true, new Term(new RangeToken('[a TO b]', 0, '', 'a', 'b', 'inclusive'))],
+            [false, new Term(new Word('word', 0, '', 'a'))],
+        ];
+    }
+
+    /**
+     * @param bool $expected
+     * @param Node $token
+     *
+     * @dataProvider acceptDataprovider
+     */
+    public function testAccepts($expected, $node)
+    {
+        $this->assertSame($expected, $this->visitor->accept($node));
+    }
+
+    public function visitDataprovider()
+    {
+        return [
+            ['[a TO b]', new Term(new RangeToken('[a TO b]', 0, '', 'a', 'b', 'inclusive'))],
+            ['{a TO b}', new Term(new RangeToken('{a TO b}', 0, '', 'a', 'b', 'exclusive'))],
+        ];
+    }
+
+    /**
+     * @param string $expected
+     * @param Node   $token
+     *
+     * @dataProvider visitDataprovider
+     */
+    public function testVisit($expected, $node)
+    {
+        $this->assertSame($expected, $this->visitor->visit($node));
+    }
+
+    public function visitWrongNodeDataprovider()
+    {
+        return [
+            [new Mandatory()],
+            [new Term(new Word('word', 0, '', 'a'))],
+        ];
+    }
+
+    /**
+     * @param string $expected
+     * @param Node   $token
+     *
+     * @dataProvider visitWrongNodeDataprovider
+     */
+    public function testVisitWrongNodeFails($node)
+    {
+       $this->expectException(\LogicException::class);
+       $this->visitor->visit($node);
+    }
+
+    public function testVisitUnknownTypeFails()
+    {
+        $this->expectException(\LogicException::class);
+        $node = new Term(new RangeToken('{a TO b}', 0, '', 'a', 'b', 'unknown'));
+        $this->visitor->visit($node);
+    }
+}

tests/Galach/Tokenizer/FullTokenizerTest.php

@@ -8,6 +8,7 @@
 use QueryTranslator\Languages\Galach\Values\Token\GroupBegin as GroupBeginToken;
 use QueryTranslator\Languages\Galach\Values\Token\GroupBegin;
 use QueryTranslator\Languages\Galach\Values\Token\Phrase as PhraseToken;
+use QueryTranslator\Languages\Galach\Values\Token\Range as RangeToken;
 use QueryTranslator\Languages\Galach\Values\Token\Tag as TagToken;
 use QueryTranslator\Languages\Galach\Values\Token\User as UserToken;
 use QueryTranslator\Languages\Galach\Values\Token\Word as WordToken;
@@ -112,6 +113,18 @@ public function providerForTestTokenize()
                     new WordToken('word\\ word', 0, '', 'word word'),
                 ],
             ],
+            [
+                '[a TO b]',
+                [
+                    new RangeToken('[a TO b]', 0, '', 'a', 'b', 'inclusive'),
+                ],
+            ],
+            [
+                '{a TO b}',
+                [
+                    new RangeToken('{a TO b}', 0, '', 'a', 'b', 'exclusive'),
+                ],
+            ],
             [
                 '"phrase"',
                 [

tests/Galach/Tokenizer/TextTokenizerTest.php

@@ -95,6 +95,20 @@ public static function setUpBeforeClass()
                 new WordToken('@user', 0, '', '@user'),
                 new Token(Tokenizer::TOKEN_GROUP_END, ')', 5),
             ],
+            '[a TO b]' => [
+                new WordToken('[a', 0, '', '[a'),
+                new Token(Tokenizer::TOKEN_WHITESPACE, ' ', 2),
+                new WordToken('TO', 3, '', 'TO'),
+                new Token(Tokenizer::TOKEN_WHITESPACE, ' ', 5),
+                new WordToken('b]', 6, '', 'b]'),
+            ],
+            '{a TO b}' => [
+                new WordToken('{a', 0, '', '{a'),
+                new Token(Tokenizer::TOKEN_WHITESPACE, ' ', 2),
+                new WordToken('TO', 3, '', 'TO'),
+                new Token(Tokenizer::TOKEN_WHITESPACE, ' ', 5),
+                new WordToken('b}', 6, '', 'b}'),
+            ],
             'domain:domain:' => [
                 new WordToken('domain:domain:', 0, '', 'domain:domain:'),
             ],

tests/Galach/Values/Token/RangeTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace QueryTranslator\Tests\Galach\Values\Token;
+
+use PHPUnit\Framework\TestCase;
+use QueryTranslator\Languages\Galach\Values\Token\Range;
+
+class RangeTest extends TestCase
+{
+    public function failingStartSymbolDataprovider()
+    {
+        return [
+            [''],
+            ['/'],
+            ['('],
+        ];
+    }
+
+    /**
+     * @dataProvider failingStartSymbolDataprovider
+     * @param string $startSymbol
+     */
+    public function testGetTypeByStartFails($startSymbol)
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        Range::getTypeByStart($startSymbol);
+    }
+
+    public function successfulStartSymbolDataprovider()
+    {
+        return [
+            ['inclusive', '['],
+            ['exclusive', '{'],
+        ];
+    }
+
+    /**
+     * @dataProvider successfulStartSymbolDataprovider
+     * @param string $expectedType
+     * @param string $startSymbol
+     */
+    public function testGetTypeByStartSucceeds($expectedType, $startSymbol)
+    {
+        $this->assertSame($expectedType, Range::getTypeByStart($startSymbol));
+    }
+
+    public function failingTypeDataprovider()
+    {
+        return [
+            [''],
+            [null],
+            ['other'],
+        ];
+    }
+
+    /**
+     * @dataProvider failingTypeDataprovider
+     * @param string $type
+     */
+    public function testConstructorFailsWrongType($type)
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        new Range('[a TO b]', 0, '', 'a', 'b', $type);
+    }
+}