Allow configurable file extension for indexing

fixtures/different_extension.inc

@@ -0,0 +1 @@
+<?php

src/Client/Workspace.php

@@ -4,6 +4,7 @@
 namespace LanguageServer\Client;
 
 use LanguageServer\ClientHandler;
+use LanguageServer\Protocol\ConfigurationItem;
 use LanguageServer\Protocol\TextDocumentIdentifier;
 use Sabre\Event\Promise;
 use JsonMapper;
@@ -44,4 +45,24 @@ public function xfiles(string $base = null): Promise
             return $this->mapper->mapArray($textDocuments, [], TextDocumentIdentifier::class);
         });
     }
+
+    /**
+     * The workspace/configuration request is sent from the server to the
+     * client to fetch configuration settings from the client.
+     *
+     * The request can fetch n configuration settings in one roundtrip.
+     * The order of the returned configuration settings correspond to the order
+     * of the passed ConfigurationItems (e.g. the first item in the response is
+     * the result for the first configuration item in the params).
+     *
+     * @param ConfigurationItem[] $items
+     * @return Promise <mixed[]>
+     */
+    public function configuration(array $items): Promise
+    {
+        return $this->handler->request(
+            'workspace/configuration',
+            ['items' => $items]
+        );
+    }
 }

src/Index/AbstractAggregateIndex.php

@@ -147,4 +147,14 @@ public function getReferenceUris(string $fqn): array
         }
         return $refs;
     }
+
+    /**
+     * Wipe all indexes for a reindex
+     */
+    public function wipe()
+    {
+        foreach ($this->getIndexes() as $index) {
+            $index->wipe();
+        }
+    }
 }

src/Index/Index.php

@@ -222,4 +222,15 @@ public function serialize()
             'staticComplete' => $this->staticComplete
         ]);
     }
+
+    /**
+     * Clear indexed references and definitions
+     */
+    public function wipe()
+    {
+        $this->definitions = [];
+        $this->references = [];
+        $this->complete = false;
+        $this->staticComplete = false;
+    }
 }

src/Index/ProjectIndex.php

@@ -35,7 +35,7 @@ public function __construct(Index $sourceIndex, DependenciesIndex $dependenciesI
     /**
      * @return ReadableIndex[]
      */
-    protected function getIndexes(): array
+    public function getIndexes(): array
     {
         return [$this->sourceIndex, $this->dependenciesIndex];
     }

src/Indexer.php

@@ -53,6 +53,11 @@ class Indexer
      */
     private $documentLoader;
 
+    /**
+     * @var Options
+     */
+    private $options;
+
     /**
      * @var \stdClasss
      */
@@ -63,6 +68,16 @@ class Indexer
      */
     private $composerJson;
 
+    /**
+     * @var bool
+     */
+    private $hasCancellationSignal;
+
+    /**
+     * @var bool
+     */
+    private $isIndexing;
+
     /**
      * @param FilesFinder       $filesFinder
      * @param string            $rootPath
@@ -93,6 +108,22 @@ public function __construct(
         $this->documentLoader = $documentLoader;
         $this->composerLock = $composerLock;
         $this->composerJson = $composerJson;
+        $this->hasCancellationSignal = false;
+        $this->isIndexing = false;
+        $this->options = new Options();
+    }
+
+    /**
+     * @param Options $options
+     */
+    public function setOptions(Options $options)
+    {
+        $this->options = $options;
+    }
+
+    public function getOptions(): Options
+    {
+        return $this->options;
     }
 
     /**
@@ -103,13 +134,14 @@ public function __construct(
     public function index(): Promise
     {
         return coroutine(function () {
-
-            $pattern = Path::makeAbsolute('**/*.php', $this->rootPath);
+            $fileTypes = implode(',', $this->options->fileTypes);
+            $pattern = Path::makeAbsolute('**/*{' . $fileTypes . '}', $this->rootPath);
             $uris = yield $this->filesFinder->find($pattern);
 
             $count = count($uris);
             $startTime = microtime(true);
             $this->client->window->logMessage(MessageType::INFO, "$count files total");
+            $this->isIndexing = true;
 
             /** @var string[] */
             $source = [];
@@ -135,6 +167,7 @@ public function index(): Promise
             $this->client->window->logMessage(MessageType::INFO, 'Indexing project for definitions and static references');
             yield $this->indexFiles($source);
             $this->sourceIndex->setStaticComplete();
+
             // Dynamic references
             $this->client->window->logMessage(MessageType::INFO, 'Indexing project for dynamic references');
             yield $this->indexFiles($source);
@@ -187,6 +220,7 @@ public function index(): Promise
                 }
             }
 
+            $this->isIndexing = false;
             $duration = (int)(microtime(true) - $startTime);
             $mem = (int)(memory_get_usage(true) / (1024 * 1024));
             $this->client->window->logMessage(
@@ -196,6 +230,35 @@ public function index(): Promise
         });
     }
 
+    /**
+     * Return current indexing state
+     *
+     * @return bool
+     */
+    public function isIndexing(): bool
+    {
+        return $this->isIndexing;
+    }
+
+    /**
+     * Cancel all running indexing processes
+     *
+     * @return Promise
+     */
+    public function cancel(): Promise
+    {
+        return coroutine(function () {
+            $this->hasCancellationSignal = true;
+
+            while ($this->isIndexing()) {
+                yield timeout();
+            }
+
+            $this->hasCancellationSignal = false;
+            $this->client->window->logMessage(MessageType::INFO, 'Indexing project canceled');
+        });
+    }
+
     /**
      * @param array $files
      * @return Promise
@@ -204,6 +267,11 @@ private function indexFiles(array $files): Promise
     {
         return coroutine(function () use ($files) {
             foreach ($files as $i => $uri) {
+                // abort current running indexing
+                if ($this->hasCancellationSignal) {
+                    return;
+                }
+
                 // Skip open documents
                 if ($this->documentLoader->isOpen($uri)) {
                     continue;