Support for inspecting index.

pkg/analysis_server/lib/src/get_handler.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analysis_server.src.get_handler;
 
+import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/domain_execution.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/protocol.dart' hide Element;
+import 'package:analysis_server/src/services/index/index.dart';
+import 'package:analysis_server/src/services/index/local_index.dart';
+import 'package:analysis_server/src/services/index/store/split_store.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 
@@ skipping 41 matching lines @@
    * The path used to request information about a specific context.
    */
   static const String CONTEXT_PATH = '/context';
 
   /**
    * The path used to request information about a element model.
    */
   static const String ELEMENT_PATH = '/element';
 
   /**
+   * The path used to request information about elements with the given name.
+   */
+  static const String INDEX_ELEMENT_BY_NAME = '/index/element-by-name';
+
+  /**
    * The path used to request an overlay contents.
    */
   static const String OVERLAY_PATH = '/overlay';
 
   /**
    * The path used to request overlays information.
    */
   static const String OVERLAYS_PATH = '/overlays';
 
   /**
@@ skipping 18 matching lines @@
    * accessing [CACHE_STATE_PATH].
    */
   static const String DESCRIPTOR_QUERY_PARAM = 'descriptor';
 
   /**
    * Query parameter used to represent the index in the [_overlayContents].
    */
   static const String ID_PARAM = 'id';
 
   /**
+   * Query parameter used to represent the name of elements to search for, when
+   * accessing [INDEX_ELEMENT_BY_NAME].
+   */
+  static const String INDEX_ELEMENT_NAME = 'name';
+
+  /**
    * Query parameter used to represent the source to search for, when accessing
    * [CACHE_ENTRY_PATH].
    */
   static const String SOURCE_QUERY_PARAM = 'entry';
 
   static final ContentType _htmlContent =
       new ContentType("text", "html", charset: "utf-8");
 
   /**
    * The socket server whose status is to be reported on.
@@ skipping 42 matching lines @@
     } else if (path == CACHE_STATE_PATH) {
       _returnCacheState(request);
     } else if (path == CACHE_ENTRY_PATH) {
       _returnCacheEntry(request);
     } else if (path == COMPLETION_PATH) {
       _returnCompletionInfo(request);
     } else if (path == CONTEXT_PATH) {
       _returnContextInfo(request);
     } else if (path == ELEMENT_PATH) {
       _returnElement(request);
+    } else if (path == INDEX_ELEMENT_BY_NAME) {
+      _returnIndexElementByName(request);
     } else if (path == OVERLAY_PATH) {
       _returnOverlayContents(request);
     } else if (path == OVERLAYS_PATH) {
       _returnOverlaysInfo(request);
     } else if (path == PERFORMANCE_PATH) {
       _returnPerformance(request);
     } else {
       _returnUnknownRequest(request);
     }
   }
@@ skipping 498 matching lines @@
       _writePage(
           buffer,
           'Analysis Server - Failure',
           [],
           (StringBuffer buffer) {
         buffer.write(HTML_ESCAPE.convert(message));
       });
     });
   }
 
+  /**
+   * Return a response containing information about elements with the given
+   * name.
+   */
+  Future _returnIndexElementByName(HttpRequest request) async {
+    AnalysisServer analysisServer = _server.analysisServer;
+    if (analysisServer == null) {
+      return _returnFailure(request, 'Analysis server not running');
+    }
+    Index index = analysisServer.index;
+    String name = request.uri.queryParameters[INDEX_ELEMENT_NAME];
+    if (name == null) {
+      return _returnFailure(
+          request,
+          'Query parameter $INDEX_ELEMENT_NAME required');
+    }
+    if (index is LocalIndex) {

[Paul Berry, 2015/02/02 23:45:47]

It would be nice to have an "else" block that generated an error message using
_returnFailure, so that in the unlikely event that index isn't a LocalIndex,
we'll get pointed in the right direction for debugging, rather than just get no
response at all.

[scheglov, 2015/02/03 03:04:49]

Done.

+      Map<List<String>, List<InspectLocation>> relations =
+          await index.findElementsByName(name);
+      _writeResponse(request, (StringBuffer buffer) {
+        _writePage(
+            buffer,
+            'Analysis Server - Index Elements',
+            ['Name: $name'],
+            (StringBuffer buffer) {
+          buffer.write('<table border="1">');
+          _writeRow(
+              buffer,
+              ['Element', 'Relationship', 'Location'],
+              header: true);
+          relations.forEach(
+              (List<String> elementPath, List<InspectLocation> relations) {
+            String elementLocation = elementPath.join(' ');
+            relations.forEach((InspectLocation location) {
+              var relString = location.relationship.identifier;
+              var locString =
+                  '${location.path} offset=${location.offset} '
+                      'length=${location.length} flags=${location.flags}';
+              _writeRow(buffer, [elementLocation, relString, locString]);
+            });
+          });
+          buffer.write('</table>');
+        });
+      });
+    }
+  }
+
   void _returnOverlayContents(HttpRequest request) {
     String idString = request.requestedUri.queryParameters[ID_PARAM];
     if (idString == null) {
       return _returnFailure(request, 'Query parameter $ID_PARAM required');
     }
     int id = int.parse(idString);
     String contents = _overlayContents[id];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(
@@ skipping 335 matching lines @@
               '&nbsp;&nbsp;',
               performance.elapsedInMilliseconds,
               '&nbsp;&nbsp;',
               performance.notificationCount,
               '&nbsp;&nbsp;',
               performance.suggestionCount,
               '&nbsp;&nbsp;',
               HTML_ESCAPE.convert(performance.snippet)]);
       ++index;
     }
-    ;
+
     buffer.write('</table>');
     buffer.write('''
       <p><strong>First (ms)</strong> - the number of milliseconds
         from when completion received the request until the first notification
         with completion results was queued for sending back to the client.
       <p><strong>Complete (ms)</strong> - the number of milliseconds
         from when completion received the request until the final notification
         with completion results was queued for sending back to the client.
       <p><strong># Notifications</strong> - the total number of notifications
         sent to the client with completion results for this request.
@@ skipping 409 matching lines @@
     } else if (value is Element) {
       String link =
           _makeLink(ELEMENT_PATH, linkParameters, value.runtimeType.toString());
       buffer.write('<i>$link</i>');
     } else {
       buffer.write(HTML_ESCAPE.convert(value.toString()));
       buffer.write(' <i>(${value.runtimeType.toString()})</i>');
     }
   }
 }