fixed context resolver issues

Author: mkusher

specs/completer/resolver/ContextResolver.spec.php

@@ -71,6 +71,10 @@
                 $context = $this->resolver->getContext('$var->');
                 expect($context->isObject())->to->be->true;
             });
+            it('has type object after object operator and space', function() {
+                $context = $this->resolver->getContext('$var-> ');
+                expect($context->isObject())->to->be->true;
+            });
             it('has type object after object operator and $this', function() {
                 $context = $this->resolver->getContext('$this->');
                 expect($context->isObject())->to->be->true;
@@ -103,5 +107,23 @@
                 expect($context->isMethodCall())->to->be->true;
             });
         });
+        describe("Variable", function() {
+            it('has type variable after $', function() {
+                $context = $this->resolver->getContext('$');
+                expect($context->isVar())->to->be->true;
+            });
+            it('has type variable after $ with TString', function() {
+                $context = $this->resolver->getContext('$var');
+                expect($context->isVar())->to->be->true;
+            });
+            it('hasn\'t type variable after space symbol', function() {
+                $context = $this->resolver->getContext('$var ');
+                expect($context->isVar())->to->be->false;
+            });
+            it('hasn\'t type variable after - symbol', function() {
+                $context = $this->resolver->getContext('$var-');
+                expect($context->isVar())->to->be->false;
+            });
+        });
     });
 });

src/Entity/Completion/Context.php

@@ -3,7 +3,6 @@
 namespace Entity\Completion;
 
 class Context {
-    const T_VAR              = 1;
     const T_USE              = 2;
     const T_NAMESPACE        = 4;
     const T_OBJECT           = 8;
@@ -13,6 +12,7 @@ class Context {
     const T_CLASS_STATIC     = 128;
     const T_CLASS_METHODS    = 256;
     const T_METHOD_CALL      = 512;
+    const T_VAR              = 1024;
 
     private $type            = 0;
     private $token;

src/Entity/Completion/Token.php

@@ -2,45 +2,53 @@
 
 namespace Entity\Completion;
 
-class Token {
-    private $symbol = "";
-    private $type   = 0;
-
-    public function __construct($code, $symbol) {
+class Token
+{
+    public function __construct($code, $symbol)
+    {
         $this->add($code, $symbol);
     }
 
-    public function add($code, $symbol) {
+    public function add($code, $symbol)
+    {
         switch ($code) {
         case T_WHITESPACE:
             $this->addType(self::T_WHITESPACE);
         case T_NS_SEPARATOR:
+            $this->addType(self::T_CONTINUE_PROCESS);
+            break;
         case T_STRING:
+            $this->addType(self::T_STRING);
             $this->addType(self::T_CONTINUE_PROCESS);
             break;
         case T_VARIABLE:
         case T_DOUBLE_COLON:
-        case T_OBJECT_OPERATOR:
             if ($this->isWhitespace()) {
-                $this->addType(self::T_UNKNOWN);
+                $this->resetType(self::T_UNKNOWN);
+                break;
+            }
+        case T_OBJECT_OPERATOR:
+            if ($this->hasString() && $this->hasWhitespace()) {
+                $this->resetType(self::T_UNKNOWN);
+                break;
             }
         case T_NAMESPACE:
         case T_USE:
         case T_NEW:
         case T_EXTENDS:
         case T_IMPLEMENTS:
-            $this->removeType(self::T_CONTINUE_PROCESS);
-            $this->addType(self::$MAP[$code]);
-            break;
+        case '$':
         case '(':
-            $this->addType(self::T_METHOD_CALL);
+            $this->resetType(self::$MAP[$code]);
             break;
         case ';':
         case ',':
+        case '-':
+        case ':':
         case '=':
         case ')':
         case ']':
-            $this->addType(self::T_TERMINATE);
+            $this->resetType(self::T_TERMINATE);
             break;
         default:
             $this->addType(self::T_UNKNOWN);
@@ -50,81 +58,111 @@ public function add($code, $symbol) {
         }
     }
 
-    public function getSymbol() {
+    public function getSymbol()
+    {
         return $this->symbol;
     }
 
-    public function getType() {
+    public function getType()
+    {
         return $this->type;
     }
 
-    public function isUnknown() {
+    public function isUnknown()
+    {
         return (bool) ($this->type & self::T_UNKNOWN);
     }
 
-    public function isReady() {
+    public function isReady()
+    {
         return !((bool) ($this->type & self::T_CONTINUE_PROCESS));
     }
 
-    public function isTerminate() {
+    public function isTerminate()
+    {
         return (bool) ($this->type & self::T_TERMINATE);
     }
 
-    public function isObjectOperator() {
+    public function isObjectOperator()
+    {
         return (bool) ($this->type & self::T_OBJECT_OPERATOR);
     }
 
-    public function isStaticOperator() {
+    public function isStaticOperator()
+    {
         return (bool) ($this->type & self::T_STATIC_OPERATOR);
     }
 
-    public function isUseOperator() {
+    public function isUseOperator()
+    {
         return (bool) ($this->type & self::T_USE_OPERATOR);
     }
 
-    public function isNamespaceOperator() {
+    public function isNamespaceOperator()
+    {
         return (bool) ($this->type & self::T_NAMESPACE_OPERATOR);
     }
 
-    public function isExtendsOperator() {
+    public function isExtendsOperator()
+    {
         return (bool) ($this->type & self::T_EXTENDS_OPERATOR);
     }
 
-    public function isImplementsOperator() {
+    public function isImplementsOperator()
+    {
         return (bool) ($this->type & self::T_IMPLEMENTS_OPERATOR);
     }
 
-    public function isNewOperator() {
+    public function isNewOperator()
+    {
         return (bool) ($this->type & self::T_NEW_OPERATOR);
     }
 
-    public function isVar() {
+    public function isVar()
+    {
         return (bool) ($this->type & self::T_VAR);
     }
 
-    public function isWhitespace() {
+    public function isWhitespace()
+    {
         return (bool) ($this->type & self::T_WHITESPACE);
     }
 
+    public function hasWhitespace()
+    {
+        return $this->isWhitespace();
+    }
+
+    public function hasString()
+    {
+        return (bool) ($this->type & self::T_STRING);
+    }
+
     public function isMethodCall()
     {
         return (bool) ($this->type & self::T_METHOD_CALL);
     }
 
-    protected function addType($type){
+    protected function resetType($type = 0)
+    {
+        $this->type = $type;
+    }
+    protected function addType($type)
+    {
         $this->type |= $type;
     }
 
     /**
      * @param integer $type
      */
-    protected function removeType($type){
+    protected function removeType($type)
+    {
         if((bool) ($this->type & $type)){
             $this->type ^= $type;
         }
     }
 
-    const T_UNKNOWN             = -1;
+    const T_UNKNOWN             = 0;
     const T_CONTINUE_PROCESS    = 1;
     const T_TERMINATE           = 2;
     const T_OBJECT_OPERATOR     = 4;
@@ -137,6 +175,7 @@ protected function removeType($type){
     const T_VAR                 = 512;
     const T_WHITESPACE          = 1024;
     const T_METHOD_CALL         = 2048;
+    const T_STRING              = 4096;
 
     protected static $MAP = [
         T_VARIABLE              => Token::T_VAR,
@@ -147,5 +186,11 @@ protected function removeType($type){
         T_NEW                   => Token::T_NEW_OPERATOR,
         T_EXTENDS               => Token::T_EXTENDS_OPERATOR,
         T_IMPLEMENTS            => Token::T_IMPLEMENTS_OPERATOR,
+        '$'                     => Token::T_VAR,
+        '('                     => Token::T_METHOD_CALL
     ];
+
+    private $symbol = "";
+    private $type   = 0;
+
 }