@enjoys/context-engine 1.4.1 → 1.4.2

package/data/definition/abap.json

@@ -183,6 +183,132 @@
           "type": "method"
         }
       }
+    },
+    "DATA": {
+      "signature": "DATA var TYPE type.",
+      "description": "Declares a data object (variable) with a specified type.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "TYPES": {
+      "signature": "TYPES: BEGIN OF ty_name, ... END OF ty_name.",
+      "description": "Defines structured types. Used to create custom data types.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "LOOP AT": {
+      "signature": "LOOP AT itab INTO wa.",
+      "description": "Iterates over the rows of an internal table.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "READ TABLE": {
+      "signature": "READ TABLE itab INTO wa WITH KEY field = value.",
+      "description": "Reads a single row from an internal table.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "DELETE": {
+      "signature": "DELETE itab WHERE condition.",
+      "description": "Deletes one or more rows from an internal table or database table.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "INSERT": {
+      "signature": "INSERT wa INTO TABLE itab.",
+      "description": "Inserts a row into an internal table or database table.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "SORT": {
+      "signature": "SORT itab BY field ASCENDING.",
+      "description": "Sorts the rows of an internal table by specified fields.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "cl_abap_typedescr": {
+      "signature": "CLASS cl_abap_typedescr",
+      "description": "Type descriptor class. Provides RTTI (Run-Time Type Information) for all ABAP types.",
+      "type": "class",
+      "module": "ABAP"
+    },
+    "cl_gui_alv_grid": {
+      "signature": "CLASS cl_gui_alv_grid",
+      "description": "ALV Grid control class. Used for displaying data in grid (table) format in GUI screens.",
+      "type": "class",
+      "module": "ABAP"
+    },
+    "WRITE": {
+      "signature": "WRITE: / value.",
+      "description": "Outputs data to the list output.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "CALL METHOD": {
+      "signature": "CALL METHOD obj->method EXPORTING param = value.",
+      "description": "Calls a method of an object or class.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "CREATE OBJECT": {
+      "signature": "CREATE OBJECT obj TYPE class.",
+      "description": "Creates an instance of a class.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "TRY": {
+      "signature": "TRY. ... CATCH cx_exception INTO lx. ... ENDTRY.",
+      "description": "Exception handling construct. Catches exceptions thrown during execution.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "RAISE EXCEPTION": {
+      "signature": "RAISE EXCEPTION TYPE cx_exception.",
+      "description": "Raises an exception that can be caught by a TRY-CATCH block.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "MESSAGE": {
+      "signature": "MESSAGE text TYPE 'I'.",
+      "description": "Sends a message to the user. Types: A(bort), E(rror), I(nfo), S(uccess), W(arning).",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "CONCATENATE": {
+      "signature": "CONCATENATE str1 str2 INTO result SEPARATED BY sep.",
+      "description": "Concatenates two or more strings.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "SPLIT": {
+      "signature": "SPLIT str AT separator INTO TABLE itab.",
+      "description": "Splits a string at each occurrence of a separator.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "CONDENSE": {
+      "signature": "CONDENSE str NO-GAPS.",
+      "description": "Removes leading/trailing spaces and reduces sequences of spaces to a single space.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "MOVE-CORRESPONDING": {
+      "signature": "MOVE-CORRESPONDING source TO target.",
+      "description": "Copies identically named components from source to target.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "FIELD-SYMBOLS": {
+      "signature": "FIELD-SYMBOLS <fs> TYPE type.",
+      "description": "Declares a field symbol (pointer/reference). Provides direct access to memory.",
+      "type": "keyword",
+      "module": "ABAP"
+    },
+    "ASSIGN": {
+      "signature": "ASSIGN itab[ idx ] TO <fs>.",
+      "description": "Assigns a memory area to a field symbol.",
+      "type": "keyword",
+      "module": "ABAP"
     }
   }
-}
+}

package/data/definition/apex.json

@@ -289,6 +289,102 @@
           "type": "property"
         }
       }
+    },
+    "SOQL": {
+      "signature": "[SELECT fields FROM object WHERE condition]",
+      "description": "Salesforce Object Query Language. Used to query Salesforce data from Apex.",
+      "type": "keyword",
+      "module": "Salesforce"
+    },
+    "HttpRequest": {
+      "signature": "class HttpRequest",
+      "description": "Use HttpRequest to programmatically create HTTP requests like GET, POST, PUT, DELETE.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "setEndpoint": {
+          "signature": "setEndpoint(url) -> void",
+          "description": "Sets the endpoint URL.",
+          "type": "method",
+          "returns": "void"
+        },
+        "setMethod": {
+          "signature": "setMethod(method) -> void",
+          "description": "Sets the HTTP method (GET, POST, PUT, DELETE).",
+          "type": "method",
+          "returns": "void"
+        },
+        "setHeader": {
+          "signature": "setHeader(key, value) -> void",
+          "description": "Sets the HTTP header.",
+          "type": "method",
+          "returns": "void"
+        },
+        "setBody": {
+          "signature": "setBody(body) -> void",
+          "description": "Sets the body of the request.",
+          "type": "method",
+          "returns": "void"
+        }
+      }
+    },
+    "HttpResponse": {
+      "signature": "class HttpResponse",
+      "description": "Use HttpResponse to handle the HTTP response returned by an HTTP request.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "getBody": {
+          "signature": "getBody() -> String",
+          "description": "Returns the body of the response.",
+          "type": "method",
+          "returns": "String"
+        },
+        "getStatusCode": {
+          "signature": "getStatusCode() -> Integer",
+          "description": "Returns the status code.",
+          "type": "method",
+          "returns": "Integer"
+        },
+        "getHeader": {
+          "signature": "getHeader(key) -> String",
+          "description": "Returns the value for the specified header.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
+    },
+    "JSON": {
+      "signature": "class JSON",
+      "description": "Contains methods for serializing/deserializing Apex objects in JSON format.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "serialize": {
+          "signature": "JSON.serialize(objectToSerialize) -> String",
+          "description": "Serializes Apex objects into JSON content.",
+          "type": "method",
+          "returns": "String"
+        },
+        "deserialize": {
+          "signature": "JSON.deserialize(jsonString, apexType) -> Object",
+          "description": "Deserializes JSON string into an Apex object of the specified type.",
+          "type": "method",
+          "returns": "Object"
+        },
+        "deserializeUntyped": {
+          "signature": "JSON.deserializeUntyped(jsonString) -> Object",
+          "description": "Deserializes JSON into collections of primitive data types.",
+          "type": "method",
+          "returns": "Object"
+        },
+        "serializePretty": {
+          "signature": "JSON.serializePretty(objectToSerialize) -> String",
+          "description": "Serializes Apex objects into JSON with indentation.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
     }
   }
-}
+}

package/data/definition/coffee.json

@@ -187,6 +187,56 @@
       "description": "Declares a class in CoffeeScript with optional inheritance using 'extends'. CoffeeScript classes compile to JavaScript prototypal inheritance and support a constructor method, instance methods, static methods (prefixed with @), and the super keyword for calling parent class methods. Class bodies use significant indentation.",
       "type": "keyword",
       "module": "CoffeeScript"
+    },
+    "Promise": {
+      "signature": "class Promise",
+      "description": "Represents the eventual completion or failure of an asynchronous operation.",
+      "type": "class",
+      "module": "global",
+      "members": {
+        "then": {
+          "signature": "then(onFulfilled, onRejected) -> Promise",
+          "description": "Appends fulfillment and rejection handlers.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "catch": {
+          "signature": "catch(onRejected) -> Promise",
+          "description": "Appends a rejection handler callback.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "finally": {
+          "signature": "finally(onFinally) -> Promise",
+          "description": "Appends a handler to be called when the promise is settled.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "all": {
+          "signature": "Promise.all(iterable) -> Promise",
+          "description": "Returns a promise that resolves when all of the promises resolve.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "race": {
+          "signature": "Promise.race(iterable) -> Promise",
+          "description": "Returns a promise that fulfills or rejects as soon as one of the promises fulfills or rejects.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "resolve": {
+          "signature": "Promise.resolve(value) -> Promise",
+          "description": "Returns a Promise object that is resolved with the given value.",
+          "type": "method",
+          "returns": "Promise"
+        },
+        "reject": {
+          "signature": "Promise.reject(reason) -> Promise",
+          "description": "Returns a Promise object that is rejected with the given reason.",
+          "type": "method",
+          "returns": "Promise"
+        }
+      }
     }
   }
-}
+}

package/data/definition/dart.json

@@ -355,6 +355,110 @@
           "type": "method"
         }
       }
+    },
+    "Widget": {
+      "signature": "abstract class Widget extends DiagnosticableTree",
+      "description": "Describes the configuration for an Element. Widgets are the central class hierarchy in the Flutter framework.",
+      "type": "class",
+      "module": "flutter:widgets"
+    },
+    "StatelessWidget": {
+      "signature": "abstract class StatelessWidget extends Widget",
+      "description": "A widget that does not require mutable state. Describes a part of the user interface by building a constellation of other widgets.",
+      "type": "class",
+      "module": "flutter:widgets",
+      "members": {
+        "build": {
+          "signature": "Widget build(BuildContext context)",
+          "description": "Describes the part of the user interface represented by this widget.",
+          "type": "method",
+          "returns": "Widget"
+        }
+      }
+    },
+    "StatefulWidget": {
+      "signature": "abstract class StatefulWidget extends Widget",
+      "description": "A widget that has mutable state.",
+      "type": "class",
+      "module": "flutter:widgets",
+      "members": {
+        "createState": {
+          "signature": "State createState()",
+          "description": "Creates the mutable state for this widget.",
+          "type": "method",
+          "returns": "State"
+        }
+      }
+    },
+    "File": {
+      "signature": "abstract class File implements FileSystemEntity",
+      "description": "A reference to a file on the file system.",
+      "type": "class",
+      "module": "dart:io",
+      "members": {
+        "readAsString": {
+          "signature": "Future<String> readAsString({Encoding encoding = utf8})",
+          "description": "Read the entire file contents as a string.",
+          "type": "method",
+          "returns": "Future<String>"
+        },
+        "writeAsString": {
+          "signature": "Future<File> writeAsString(String contents)",
+          "description": "Write a string to a file.",
+          "type": "method",
+          "returns": "Future<File>"
+        },
+        "exists": {
+          "signature": "Future<bool> exists()",
+          "description": "Checks whether the file system entity with this path exists.",
+          "type": "method",
+          "returns": "Future<bool>"
+        },
+        "delete": {
+          "signature": "Future<FileSystemEntity> delete({bool recursive = false})",
+          "description": "Deletes this file system entity.",
+          "type": "method",
+          "returns": "Future<FileSystemEntity>"
+        },
+        "readAsBytes": {
+          "signature": "Future<Uint8List> readAsBytes()",
+          "description": "Read the entire file contents as a list of bytes.",
+          "type": "method",
+          "returns": "Future<Uint8List>"
+        },
+        "length": {
+          "signature": "Future<int> length()",
+          "description": "The length of the file.",
+          "type": "method",
+          "returns": "Future<int>"
+        }
+      }
+    },
+    "RegExp": {
+      "signature": "abstract class RegExp implements Pattern",
+      "description": "A regular expression pattern.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "hasMatch": {
+          "signature": "bool hasMatch(String input)",
+          "description": "Whether the regular expression has a match in the string input.",
+          "type": "method",
+          "returns": "bool"
+        },
+        "firstMatch": {
+          "signature": "RegExpMatch? firstMatch(String input)",
+          "description": "Returns the first match of the regular expression in the string.",
+          "type": "method",
+          "returns": "RegExpMatch?"
+        },
+        "allMatches": {
+          "signature": "Iterable<RegExpMatch> allMatches(String input, [int start = 0])",
+          "description": "Returns an iterable of all matches.",
+          "type": "method",
+          "returns": "Iterable<RegExpMatch>"
+        }
+      }
     }
   }
-}
+}

package/data/definition/elixir.json

@@ -239,6 +239,120 @@
           "type": "function"
         }
       }
+    },
+    "File": {
+      "signature": "defmodule File",
+      "description": "Contains functions to manipulate files.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "read": {
+          "signature": "File.read(path) :: {:ok, binary} | {:error, posix}",
+          "description": "Returns {:ok, binary} with the contents of the given filename, or {:error, reason}.",
+          "type": "function",
+          "returns": "{:ok, binary} | {:error, posix}"
+        },
+        "write": {
+          "signature": "File.write(path, content) :: :ok | {:error, posix}",
+          "description": "Writes content to the file at path.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "exists?": {
+          "signature": "File.exists?(path) :: boolean",
+          "description": "Returns true if the given path exists.",
+          "type": "function",
+          "returns": "boolean"
+        },
+        "rm": {
+          "signature": "File.rm(path) :: :ok | {:error, posix}",
+          "description": "Tries to delete the file at path.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "mkdir_p": {
+          "signature": "File.mkdir_p(path) :: :ok | {:error, posix}",
+          "description": "Tries to create the directory path. Missing parent directories are created.",
+          "type": "function",
+          "returns": ":ok | {:error, posix}"
+        },
+        "ls": {
+          "signature": "File.ls(path) :: {:ok, list(String.t)} | {:error, posix}",
+          "description": "Returns {:ok, list} with the list of files in the given directory.",
+          "type": "function",
+          "returns": "{:ok, list(String.t)} | {:error, posix}"
+        },
+        "stat": {
+          "signature": "File.stat(path) :: {:ok, File.Stat.t} | {:error, posix}",
+          "description": "Returns information about the path.",
+          "type": "function",
+          "returns": "{:ok, File.Stat.t} | {:error, posix}"
+        }
+      }
+    },
+    "Supervisor": {
+      "signature": "defmodule Supervisor",
+      "description": "A behaviour module for implementing supervisors. A supervisor is a process which supervises other processes, called child processes.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "start_link": {
+          "signature": "Supervisor.start_link(children, options) :: {:ok, pid}",
+          "description": "Starts a supervisor with the given children.",
+          "type": "function",
+          "returns": "{:ok, pid}"
+        },
+        "init": {
+          "signature": "Supervisor.init(children, options) :: {:ok, tuple}",
+          "description": "Receives a list of children to initialize.",
+          "type": "callback",
+          "returns": "{:ok, tuple}"
+        },
+        "which_children": {
+          "signature": "Supervisor.which_children(supervisor) :: list",
+          "description": "Returns a list with information about all children.",
+          "type": "function",
+          "returns": "list"
+        },
+        "count_children": {
+          "signature": "Supervisor.count_children(supervisor) :: map",
+          "description": "Returns a map containing count values for the supervisor.",
+          "type": "function",
+          "returns": "map"
+        }
+      }
+    },
+    "Process": {
+      "signature": "defmodule Process",
+      "description": "Conveniences for working with processes and the process dictionary.",
+      "type": "module",
+      "module": "Elixir",
+      "members": {
+        "spawn": {
+          "signature": "Process.spawn(fun, options) :: pid",
+          "description": "Spawns the given function according to the given options.",
+          "type": "function",
+          "returns": "pid"
+        },
+        "send": {
+          "signature": "Process.send(dest, msg, options) :: :ok",
+          "description": "Sends a message to the given process.",
+          "type": "function",
+          "returns": ":ok"
+        },
+        "alive?": {
+          "signature": "Process.alive?(pid) :: boolean",
+          "description": "Tells whether the given process is alive on the local node.",
+          "type": "function",
+          "returns": "boolean"
+        },
+        "sleep": {
+          "signature": "Process.sleep(timeout) :: :ok",
+          "description": "Sleeps the current process for the given timeout.",
+          "type": "function",
+          "returns": ":ok"
+        }
+      }
     }
   }
-}
+}