Exemple #1
0
        string GetAutocomplete(string json)
        {
            /*
             *  Format:
             *      textDocument
             *      caret
             *          caret.line
             *          caret.character
             */
            PosData posData = GetPosData(json);

            if (posData == null)
            {
                return(null);
            }

            List <CompletionItem> completion = new List <CompletionItem>();

            if (posData.SelectedNode != null)
            {
                switch (posData.SelectedNode.FirstOrDefault())
                {
                // Ruleset
                case RulesetNode rulesetNode:

                    completion.AddRange(new CompletionItem[]
                    {
                        new CompletionItem("rule")
                        {
                            kind = CompletionItem.Keyword, textEdit = TextEdit.Insert(posData.Caret, Extras.Lines(
                                                                                          "rule: \"My Rule\"",
                                                                                          "Event.OngoingGlobal",
                                                                                          "{",
                                                                                          "}"
                                                                                          ))
                        },
                        new CompletionItem("define")
                        {
                            kind = CompletionItem.Keyword
                        },
                        new CompletionItem("method")
                        {
                            kind = CompletionItem.Keyword, textEdit = TextEdit.Insert(posData.Caret, Extras.Lines(
                                                                                          "method myMethod()",
                                                                                          "{",
                                                                                          "}"
                                                                                          ))
                        }
                    });
                    break;

                // Rule node
                case RuleNode ruleNode:

                    // Event type
                    if (ruleNode.IsEventOptionSelected(posData.Caret))
                    {
                        completion.AddRange(EnumData.GetEnum <RuleEvent>().GetCompletion());
                    }

                    // Player
                    else if (ruleNode.IsPlayerOptionSelected(posData.Caret))
                    {
                        completion.AddRange(EnumData.GetEnum <PlayerSelector>().GetCompletion());
                    }

                    // Team
                    else if (ruleNode.IsTeamOptionSelected(posData.Caret))
                    {
                        completion.AddRange(EnumData.GetEnum <Team>().GetCompletion());
                    }

                    else if (ruleNode.IsIfSelected(posData.Caret))
                    {
                        completion.AddRange(Element.GetCompletion(true, false));
                    }

                    else
                    {
                        completion.AddRange(new CompletionItem[]
                        {
                            new CompletionItem("Event")
                            {
                                kind = CompletionItem.Enum
                            },
                            new CompletionItem("Team")
                            {
                                kind = CompletionItem.Enum
                            },
                            new CompletionItem("Player")
                            {
                                kind = CompletionItem.Enum
                            },
                        });
                    }
                    break;

                // Actions
                case BlockNode blockNode:

                    // Get all action methods
                    completion.AddRange(Element.GetCompletion(true, true));
                    completion.AddRange(CustomMethodData.GetCompletion());

                    if (parserData.Success)
                    {
                        // Get all variables
                        if (blockNode.RelatedScopeGroup != null)
                        {
                            completion.AddRange(blockNode.RelatedScopeGroup.GetCompletionItems(posData.Caret));
                        }
                        // Get custom methods
                        if (parserData.UserMethods != null)
                        {
                            completion.AddRange(UserMethod.CollectionCompletion(parserData.UserMethods.ToArray()));
                        }
                        // Get structs
                        if (parserData.DefinedTypes != null)
                        {
                            completion.AddRange(DefinedType.CollectionCompletion(parserData.DefinedTypes.ToArray()));
                        }
                    }

                    break;

                // Values
                case MethodNode methodNode:

                    completion.AddRange(Element.GetCompletion(true, false));
                    completion.AddRange(EnumData.GetAllEnumCompletion());
                    completion.AddRange(CustomMethodData.GetCompletion());

                    if (parserData.Success)
                    {
                        // Get all variables
                        if (methodNode.RelatedScopeGroup != null)
                        {
                            completion.AddRange(methodNode.RelatedScopeGroup?.GetCompletionItems(posData.Caret));
                        }
                        // Get custom methods
                        if (parserData.UserMethods != null)
                        {
                            completion.AddRange(UserMethod.CollectionCompletion(parserData.UserMethods.ToArray()));
                        }
                    }

                    break;

                // If the selected node is a string node, show all strings.
                case StringNode stringNode:

                    completion.AddRange(Constants.Strings.Select(str =>
                                                                 new CompletionItem(str)
                    {
                        kind = CompletionItem.Text
                    }
                                                                 ));

                    break;

                case EnumNode enumNode:
                    var add = EnumData.GetEnum(enumNode.Type)?.GetCompletion();

                    if (add != null)
                    {
                        completion.AddRange(add);
                    }

                    break;

                case ImportNode importNode:

                    string currentPath = importNode.File;

                    string path = Extras.CombinePathWithDotNotation(posData.File, importNode.File);

                    if (path != null)
                    {
                        completion.Add(new CompletionItem("../")
                        {
                            kind = CompletionItem.Folder
                        });

                        // GetDirectoryName can return null even if path isn't null.
                        path = Path.GetDirectoryName(path);

                        if (path != null)
                        {
                            foreach (string fullDirectoryPath in Directory.GetDirectories(path))
                            {
                                string directory = new DirectoryInfo(fullDirectoryPath).Name;
                                completion.Add(new CompletionItem(directory)
                                {
                                    kind = CompletionItem.Folder
                                });
                            }
                            foreach (string fullFilePath in Directory.GetFiles(path))
                            {
                                string file = Path.GetFileName(fullFilePath);
                                completion.Add(new CompletionItem(file)
                                {
                                    kind = CompletionItem.File
                                });
                            }
                        }
                    }

                    break;
                }
            }

            return(JsonConvert.SerializeObject(completion.ToArray()));
        }
        static string GetAutocomplete(string json)
        {
            /*
             *  Format:
             *      textDocument
             *      caret
             *          caret.line
             *          caret.character
             */
            dynamic inputJson = JsonConvert.DeserializeObject(json);

            string document = inputJson.textDocument;

            int line      = inputJson.caret.line;
            int character = inputJson.caret.character;
            Pos caret     = new Pos(line, character);

            var parser = ParserData.GetParser(document, new Parse.Pos(caret.line, caret.character));

            List <CompletionItem> completion = new List <CompletionItem>();

            switch (parser.Bav?.SelectedNode.FirstOrDefault())
            {
            // Ruleset
            case RulesetNode rulesetNode:

                completion.AddRange(new CompletionItem[]
                {
                    // TODO insert text
                    new CompletionItem("rule")
                    {
                        kind = CompletionItem.Keyword
                    },
                    new CompletionItem("define")
                    {
                        kind = CompletionItem.Keyword
                    },
                    new CompletionItem("method")
                    {
                        kind = CompletionItem.Keyword
                    }
                });
                break;

            // Rule node
            case RuleNode ruleNode:

                // Event type
                if (ruleNode.IsEventOptionSelected())
                {
                    completion.AddRange(EnumData.GetEnum <RuleEvent>().GetCompletion());
                }

                // Player
                else if (ruleNode.IsPlayerOptionSelected())
                {
                    completion.AddRange(EnumData.GetEnum <PlayerSelector>().GetCompletion());
                }

                // Team
                else if (ruleNode.IsTeamOptionSelected())
                {
                    completion.AddRange(EnumData.GetEnum <TeamSelector>().GetCompletion());
                }

                else
                {
                    completion.AddRange(new CompletionItem[]
                    {
                        new CompletionItem("Event")
                        {
                            kind = CompletionItem.Enum
                        },
                        new CompletionItem("Team")
                        {
                            kind = CompletionItem.Enum
                        },
                        new CompletionItem("Player")
                        {
                            kind = CompletionItem.Enum
                        },
                    });
                }
                break;

            // Actions
            case BlockNode blockNode:

                // Get all action methods
                completion.AddRange(Element.ActionList.Select(m =>
                                                              new CompletionItem(m.Name.Substring(2))
                {
                    kind   = CompletionItem.Method,
                    detail = ((Element)Activator.CreateInstance(m)).ToString(),
                }));
                if (parser.Success)
                {
                    // Get all variables
                    if (blockNode.RelatedScopeGroup != null)
                    {
                        completion.AddRange(blockNode.RelatedScopeGroup.GetCompletionItems());
                    }
                    // Get custom methods
                    if (parser.UserMethods != null)
                    {
                        completion.AddRange(UserMethod.CollectionCompletion(parser.UserMethods));
                    }
                }

                break;

            // Values
            case MethodNode methodNode:

                completion.AddRange(Element.ValueList.Select(m =>
                                                             new CompletionItem(m.Name.Substring(2))
                {
                    kind   = CompletionItem.Method,
                    detail = ((Element)Activator.CreateInstance(m)).ToString(),
                }));

                completion.AddRange(EnumData.GetAllEnumCompletion());

                if (parser.Success)
                {
                    // Get all variables
                    if (methodNode.RelatedScopeGroup != null)
                    {
                        completion.AddRange(methodNode.RelatedScopeGroup?.GetCompletionItems());
                    }
                    // Get custom methods
                    if (parser.UserMethods != null)
                    {
                        completion.AddRange(UserMethod.CollectionCompletion(parser.UserMethods));
                    }
                }

                break;

            // If the selected node is a string node, show all strings.
            case StringNode stringNode:

                completion.AddRange(Constants.Strings.Select(str =>
                                                             new CompletionItem(str)
                {
                    kind = CompletionItem.Text
                }
                                                             ));

                break;

            case EnumNode enumNode:
                var add = EnumData.GetEnum(enumNode.Type)?.GetCompletion();

                if (add != null)
                {
                    completion.AddRange(add);
                }

                break;
            }

            return(JsonConvert.SerializeObject(completion.ToArray()));
        }