Fixed indentation issue with strongly typed placeholders by sending the current GraphQL environment to the language service (#130)

Author: jimkyndemeyer

src/main/com/intellij/lang/jsgraphql/ide/injection/JSGraphQLTemplateFragmentLanguageInjector.java

@@ -14,6 +14,7 @@
 import com.intellij.lang.javascript.JSTokenTypes;
 import com.intellij.lang.javascript.psi.ecma6.JSStringTemplateExpression;
 import com.intellij.lang.jsgraphql.JSGraphQLLanguage;
+import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiLanguageInjectionHost;
@@ -26,11 +27,13 @@ public class JSGraphQLTemplateFragmentLanguageInjector implements MultiHostInjec
 
     private static final ArrayList<Class<JSStringTemplateExpression>> INJECTION_CLASSES = Lists.newArrayList(JSStringTemplateExpression.class);
 
+    public final static ThreadLocal<String> CURRENT_INJECTION_ENVIRONMENT = new ThreadLocal<>();
+
     @Override
     public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull PsiElement context) {
 
-
-        if(JSGraphQLLanguageInjectionUtil.isJSGraphQLLanguageInjectionTarget(context)) {
+        final Ref<String> envRef = new Ref<>(null);
+        if(JSGraphQLLanguageInjectionUtil.isJSGraphQLLanguageInjectionTarget(context, envRef)) {
 
             final JSStringTemplateExpression template = (JSStringTemplateExpression)context;
 
@@ -60,7 +63,13 @@ public void getLanguagesToInject(@NotNull MultiHostRegistrar registrar, @NotNull
                 }
             }
 
-            registrar.doneInjecting();
+            try {
+                CURRENT_INJECTION_ENVIRONMENT.set(envRef.get());
+                // lexing and parsing occurs inside the next method, allowing us to access the env from the thread local
+                registrar.doneInjecting();
+            } finally {
+                CURRENT_INJECTION_ENVIRONMENT.remove();
+            }
         }
     }
 

src/main/com/intellij/lang/jsgraphql/ide/notifications/JSGraphQLConfigEditorNotificationProvider.java

@@ -151,7 +151,7 @@ protected Runnable getConfigureAction() {
                 FileEditorManager.getInstance(myProject).openFile(config, true, true);
                 if(setProjectDir) {
                     // fetch tokens from the client to force it to set the project dir base on the module we picked
-                    JSGraphQLNodeLanguageServiceClient.getTokens("", myProject);
+                    JSGraphQLNodeLanguageServiceClient.getTokens("", myProject, null);
                 }
                 Notifications.Bus.notify(new Notification("GraphQL", "Created " + JSGraphQLConfigurationProvider.GRAPHQL_CONFIG_JSON + " and " + JSGraphQLConfigurationProvider.GRAPHQL_DEFAULT_SCHEMA, "Edit to load your own GraphQL schema.", NotificationType.INFORMATION));
             }

src/main/com/intellij/lang/jsgraphql/languageservice/JSGraphQLNodeLanguageServiceClient.java

@@ -28,8 +28,8 @@ public class JSGraphQLNodeLanguageServiceClient {
     private static final Logger log = Logger.getInstance(JSGraphQLNodeLanguageServiceClient.class);
     private static Map<Project, JSGraphQLNodeLanguageServiceInstance> languageServiceInstances = Maps.newConcurrentMap();
 
-    public static TokensResponse getTokens(String buffer, Project project) {
-        final BufferRequest request = BufferRequest.getTokens(buffer);
+    public static TokensResponse getTokens(String buffer, Project project, String environment) {
+        final BufferRequest request = BufferRequest.getTokens(buffer, environment);
         return executeRequest(request, TokensResponse.class, project);
     }
 

src/main/com/intellij/lang/jsgraphql/languageservice/api/BufferRequest.java

@@ -17,8 +17,8 @@ protected BufferRequest(String command, String environment) {
         super(command, environment);
     }
 
-    public static BufferRequest getTokens(String buffer) {
-        BufferRequest ret = new BufferRequest("getTokens", null);
+    public static BufferRequest getTokens(String buffer, String environment) {
+        BufferRequest ret = new BufferRequest("getTokens", environment);
         ret.buffer = buffer;
         return ret;
     }

src/main/com/intellij/lang/jsgraphql/lexer/JSGraphQLLexer.java

@@ -11,6 +11,7 @@
 import com.intellij.lang.jsgraphql.JSGraphQLDebugUtil;
 import com.intellij.lang.jsgraphql.JSGraphQLKeywords;
 import com.intellij.lang.jsgraphql.JSGraphQLTokenTypes;
+import com.intellij.lang.jsgraphql.ide.injection.JSGraphQLTemplateFragmentLanguageInjector;
 import com.intellij.lang.jsgraphql.languageservice.JSGraphQLNodeLanguageServiceClient;
 import com.intellij.lang.jsgraphql.languageservice.api.Token;
 import com.intellij.lang.jsgraphql.languageservice.api.TokensResponse;
@@ -41,6 +42,8 @@ public class JSGraphQLLexer extends LexerBase {
     private int startOffset;
     private int endOffset;
 
+    private String environment;
+
     private TokensResponse response;
 
     private final Project project;
@@ -63,6 +66,8 @@ public void start(@NotNull CharSequence buffer, int startOffset, int endOffset,
         this.tokens = Lists.newArrayList();
         this.response = null;
 
+        this.environment = JSGraphQLTemplateFragmentLanguageInjector.CURRENT_INJECTION_ENVIRONMENT.get();
+
         fetchTokensFromLanguageService();
     }
 
@@ -75,7 +80,7 @@ private void fetchTokensFromLanguageService() {
         }
 
         // get the response using the client
-        response = JSGraphQLNodeLanguageServiceClient.getTokens(bufferAsString, project);
+        response = JSGraphQLNodeLanguageServiceClient.getTokens(bufferAsString, project, environment);
 
         if (response == null) {
             // blank

src/main/com/intellij/lang/jsgraphql/parser/JSGraphQLParser.java

@@ -218,10 +218,13 @@ private void endScope(@NotNull PsiBuilder builder, Ref<Integer> tokenIndex, Stac
 
     private List<PropertyScope> getPropertyScopes(List<JSGraphQLToken> tokens) {
 
-        final List<JSGraphQLToken> astTokens = tokens.stream()
+        List<JSGraphQLToken> astTokens = tokens.stream()
                 .filter((token) -> token.tokenType != JSGraphQLTokenTypes.WHITESPACE && token.tokenType != JSGraphQLTokenTypes.COMMENT)
                 .collect(Collectors.toList());
 
+        // remove ${jsVar} placeholders from consideration
+        astTokens = removeVariablePlaceholders(astTokens);
+
         final List<PropertyScope> ret = Lists.newArrayList();
         final Stack<PropertyScope> scopes = new Stack<>();
 
@@ -335,6 +338,51 @@ private List<PropertyScope> getPropertyScopes(List<JSGraphQLToken> tokens) {
         return ret;
     }
 
+    /**
+     * Removes placeholders like ${jsVariable.foo.bar} from the astTokens since the curly braces shouldn't count as selection sets
+     */
+    private List<JSGraphQLToken> removeVariablePlaceholders(List<JSGraphQLToken> astTokens) {
+        final List<JSGraphQLToken> tokens = Lists.newArrayListWithExpectedSize(astTokens.size());
+        for (int i = 0; i < astTokens.size(); i++) {
+            JSGraphQLToken currentToken = astTokens.get(i);
+            if(currentToken.tokenType == JSGraphQLTokenTypes.VARIABLE) {
+                // found a '$' so if the next token is a '{' then it's a placeholder
+                if(i < astTokens.size() - 1 /* there is a next token */) {
+                    final JSGraphQLToken nextToken = astTokens.get(i + 1);
+                    if(nextToken.tokenType == JSGraphQLTokenTypes.LBRACE) {
+                        // found a placeholder, so skip tokens until we on the other side of the placeholder
+                        tokens.add(currentToken);
+                        currentToken = null;
+                        int openBraces = 1;
+                        // start at the token that comes after '$' and '{'
+                        for(int j = i + 2; j < astTokens.size(); j++) {
+                            final JSGraphQLToken token = astTokens.get(j);
+                            i = j;
+                            if(token.tokenType == JSGraphQLTokenTypes.LBRACE) {
+                                openBraces++;
+                            } else if(token.tokenType == JSGraphQLTokenTypes.RBRACE) {
+                                openBraces--;
+                                if(openBraces == 0) {
+                                    // found the end of the placeholder
+                                    if(j < astTokens.size() - 1) {
+                                        // there's a next token which is the one we want to add
+                                        i++;
+                                        currentToken = astTokens.get(i);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if(currentToken != null) {
+                tokens.add(currentToken);
+            }
+        }
+        return tokens;
+    }
+
     private boolean isValueForAttribute(List<JSGraphQLToken> astTokens, PropertyScope attributeNameScope, PropertyScope attributeValue) {
         for(int i = attributeNameScope.astTokenStartIndex + 1; i < astTokens.size(); i++) {
             final JSGraphQLToken token = astTokens.get(i);