@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/freemarker2.json

@@ -0,0 +1,176 @@
+{
+  "language": "freemarker2",
+  "definitions": {
+    "string_builtins": {
+      "signature": "expr?builtin_name",
+      "description": "FreeMarker string built-ins provide powerful string manipulation capabilities applied using the ?suffix syntax on string expressions. They cover case conversion, trimming, searching, replacing, splitting, and formatting — enabling rich text processing directly within templates without Java code.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "length": {
+          "signature": "string?length -> number",
+          "description": "Returns the number of characters in the string as an integer value.",
+          "type": "method"
+        },
+        "upper_case": {
+          "signature": "string?upper_case -> string",
+          "description": "Converts all characters in the string to uppercase according to the current locale settings.",
+          "type": "method"
+        },
+        "lower_case": {
+          "signature": "string?lower_case -> string",
+          "description": "Converts all characters in the string to lowercase according to the current locale settings.",
+          "type": "method"
+        },
+        "cap_first": {
+          "signature": "string?cap_first -> string",
+          "description": "Capitalizes the first letter of the string while leaving the rest unchanged.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "string?trim -> string",
+          "description": "Removes leading and trailing whitespace characters from the string.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "string?contains(substring) -> boolean",
+          "description": "Returns true if the string contains the specified substring anywhere within it.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "string?replace(target, replacement) -> string",
+          "description": "Replaces all occurrences of the target substring with the replacement string.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "string?split(separator) -> sequence",
+          "description": "Splits the string at each occurrence of the separator and returns a sequence of substrings.",
+          "type": "method"
+        }
+      }
+    },
+    "sequence_builtins": {
+      "signature": "sequence?builtin_name",
+      "description": "FreeMarker sequence built-ins operate on ordered collections (arrays/lists) and provide operations for querying size, sorting, reversing, joining, chunking, and filtering sequences. Sequences are zero-indexed and support random access by index.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "size": {
+          "signature": "sequence?size -> number",
+          "description": "Returns the number of elements in the sequence.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "sequence?sort -> sequence",
+          "description": "Returns a new sequence with elements sorted in ascending order using natural ordering.",
+          "type": "method"
+        },
+        "sort_by": {
+          "signature": "sequence?sort_by(key) -> sequence",
+          "description": "Sorts a sequence of hashes by the specified key name, returning a new sorted sequence.",
+          "type": "method"
+        },
+        "reverse": {
+          "signature": "sequence?reverse -> sequence",
+          "description": "Returns a new sequence with elements in reverse order.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "sequence?first -> element",
+          "description": "Returns the first element of the sequence, or is missing if the sequence is empty.",
+          "type": "method"
+        },
+        "last": {
+          "signature": "sequence?last -> element",
+          "description": "Returns the last element of the sequence.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "sequence?join(separator) -> string",
+          "description": "Concatenates all sequence elements into a single string separated by the given separator.",
+          "type": "method"
+        },
+        "chunk": {
+          "signature": "sequence?chunk(size) -> sequence",
+          "description": "Splits the sequence into sub-sequences of the given maximum size, useful for creating rows/columns in tables.",
+          "type": "method"
+        }
+      }
+    },
+    "hash_builtins": {
+      "signature": "hash?builtin_name",
+      "description": "FreeMarker hash built-ins operate on hash (map/dictionary) values and provide access to the keys and values collections. Hashes in FreeMarker map string keys to arbitrary values and are the primary structure for data model objects passed from the Java backend.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "keys": {
+          "signature": "hash?keys -> sequence",
+          "description": "Returns a sequence of all key names in the hash.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "hash?values -> sequence",
+          "description": "Returns a sequence of all values in the hash, in the same order as their corresponding keys.",
+          "type": "method"
+        }
+      }
+    },
+    "number_builtins": {
+      "signature": "number?builtin_name",
+      "description": "FreeMarker number built-ins provide formatting and conversion operations for numeric values including rounding, absolute value, and string conversion with locale-aware formatting. Numbers in FreeMarker automatically handle both integers and floating-point values.",
+      "type": "class",
+      "module": "FreeMarker Built-ins",
+      "members": {
+        "string": {
+          "signature": "number?string(format) -> string",
+          "description": "Converts the number to a formatted string; format can be 'computer' for locale-independent, 'currency', 'percent', or a Java DecimalFormat pattern.",
+          "type": "method"
+        },
+        "abs": {
+          "signature": "number?abs -> number",
+          "description": "Returns the absolute (non-negative) value of the number.",
+          "type": "method"
+        },
+        "round": {
+          "signature": "number?round -> number",
+          "description": "Rounds the number to the nearest integer using half-up rounding.",
+          "type": "method"
+        },
+        "floor": {
+          "signature": "number?floor -> number",
+          "description": "Rounds the number down to the nearest integer (toward negative infinity).",
+          "type": "method"
+        },
+        "ceiling": {
+          "signature": "number?ceiling -> number",
+          "description": "Rounds the number up to the nearest integer (toward positive infinity).",
+          "type": "method"
+        }
+      }
+    },
+    "if_directive": {
+      "signature": "<#if condition>...<#elseif condition>...<#else>...</#if>",
+      "description": "The conditional directive that renders its enclosed content only when the condition evaluates to true. Supports optional elseif and else branches for multi-way branching. Conditions can use comparison operators (==, !=, <, >, <=, >=), logical operators (&&, ||, !), and built-in tests.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "list_directive": {
+      "signature": "<#list sequence as item>...<#sep>separator</#sep></#list>",
+      "description": "Iterates over a sequence or collection, rendering the body once for each element. The item variable holds the current element. Supports <#sep> for inter-element separators, <#items> for explicit item blocks, and <#else> for empty collection handling. Tracks iteration via item?index, item?counter, and item?is_last.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "assign_directive": {
+      "signature": "<#assign name = value> | <#assign name>capture</#assign>",
+      "description": "Creates or replaces a variable in the current template namespace. The simple form assigns an expression value directly. The capture form captures all output between the tags as a string value, useful for building complex strings from template output.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    },
+    "macro_directive": {
+      "signature": "<#macro name param1 param2=default>body</#macro>",
+      "description": "Defines a reusable template fragment (macro) with optional parameters and default values. Macros are called with the <@name> syntax and support nested content via <#nested>. They enable DRY template design by encapsulating repeated layout patterns.",
+      "type": "keyword",
+      "module": "FreeMarker Directives"
+    }
+  }
+}

package/data/defination/julia.json

@@ -0,0 +1,232 @@
+{
+  "language": "julia",
+  "definitions": {
+    "Array": {
+      "signature": "Array{T,N}(undef, dims...)",
+      "description": "The fundamental multidimensional container type parameterized by element type T and dimensionality N. Arrays in Julia are column-major, mutable, and support broadcasting, comprehensions, and high-performance linear algebra operations through BLAS integration.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "push!": {
+          "signature": "push!(collection, items...) -> collection",
+          "description": "Appends one or more items to the end of the collection, mutating it in place and returning it.",
+          "type": "method"
+        },
+        "pop!": {
+          "signature": "pop!(collection) -> item",
+          "description": "Removes and returns the last element from the collection.",
+          "type": "method"
+        },
+        "length": {
+          "signature": "length(collection) -> Int",
+          "description": "Returns the total number of elements in the collection.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "size(A, [dim]) -> Tuple or Int",
+          "description": "Returns a tuple of dimensions of array A, or the size along a specific dimension if dim is given.",
+          "type": "method"
+        },
+        "sort!": {
+          "signature": "sort!(v; alg=defalg, lt=isless, by=identity, rev=false) -> v",
+          "description": "Sorts the vector v in place using the specified algorithm and comparison functions.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "filter(f, a) -> Array",
+          "description": "Returns a new array containing only the elements of a for which function f returns true.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "map(f, c...) -> Array",
+          "description": "Transforms each element by applying function f, returning a new collection of results.",
+          "type": "method"
+        },
+        "reshape": {
+          "signature": "reshape(A, dims...) -> AbstractArray",
+          "description": "Returns an array with the same data as A but with different dimensions specified by dims.",
+          "type": "method"
+        }
+      }
+    },
+    "Dict": {
+      "signature": "Dict{K,V}(pairs...)",
+      "description": "A hash-table-based dictionary mapping keys of type K to values of type V. Supports iteration over key-value pairs, efficient lookup, insertion, and deletion. Dict is the standard mutable associative container in Julia's Base library.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "get": {
+          "signature": "get(collection, key, default) -> value",
+          "description": "Returns the value for key if it exists in the collection, otherwise returns the default value.",
+          "type": "method"
+        },
+        "haskey": {
+          "signature": "haskey(collection, key) -> Bool",
+          "description": "Determines whether the collection has a mapping for the given key, returning true or false.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "keys(dict) -> KeySet",
+          "description": "Returns an iterator over all keys in the dictionary.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "values(dict) -> ValueIterator",
+          "description": "Returns an iterator over all values in the dictionary.",
+          "type": "method"
+        },
+        "delete!": {
+          "signature": "delete!(collection, key) -> collection",
+          "description": "Deletes the mapping for the given key from the collection and returns the modified collection.",
+          "type": "method"
+        },
+        "merge": {
+          "signature": "merge(d1, d2...) -> Dict",
+          "description": "Constructs a merged dictionary from the given dictionaries, with later values overwriting earlier ones for duplicate keys.",
+          "type": "method"
+        }
+      }
+    },
+    "String": {
+      "signature": "String(data::AbstractVector{UInt8})",
+      "description": "An immutable UTF-8 encoded string type. Strings in Julia support Unicode natively, are indexed by byte position (not character index), and provide extensive pattern matching, interpolation with $ syntax, and conversion utilities.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "occursin": {
+          "signature": "occursin(needle, haystack) -> Bool",
+          "description": "Determines whether the first argument is a substring of the second, supporting both string and regex patterns.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "replace(s, pat => r; count=typemax(Int)) -> String",
+          "description": "Returns a new string with occurrences of pat replaced by r, optionally limiting the number of replacements.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "split(str, dlm; limit=0, keepempty=true) -> Vector{SubString}",
+          "description": "Splits the string at each occurrence of the delimiter and returns a vector of substrings.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "join(strings, delim=\"\") -> String",
+          "description": "Concatenates an iterable collection of strings with the given delimiter between elements.",
+          "type": "method"
+        },
+        "strip": {
+          "signature": "strip(s::AbstractString, [chars]) -> SubString",
+          "description": "Removes leading and trailing whitespace or specified characters from the string.",
+          "type": "method"
+        }
+      }
+    },
+    "Tuple": {
+      "signature": "Tuple{T1, T2, ...}",
+      "description": "An immutable, fixed-size, ordered collection of elements, each potentially having a different type. Tuples are used extensively for multiple return values, function argument packing, and as dictionary keys due to their immutability and efficient memory layout.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "length": {
+          "signature": "length(t::Tuple) -> Int",
+          "description": "Returns the number of elements in the tuple.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "first(t::Tuple) -> element",
+          "description": "Returns the first element of the tuple.",
+          "type": "method"
+        },
+        "last": {
+          "signature": "last(t::Tuple) -> element",
+          "description": "Returns the last element of the tuple.",
+          "type": "method"
+        }
+      }
+    },
+    "Set": {
+      "signature": "Set{T}(itr)",
+      "description": "An unordered collection of unique elements of type T, backed by a Dict. Sets support standard mathematical operations including union, intersection, difference, and symmetric difference, as well as membership testing with the in operator.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "union": {
+          "signature": "union(s, itrs...) -> Set",
+          "description": "Constructs the union of sets, containing all elements that appear in any of the arguments.",
+          "type": "method"
+        },
+        "intersect": {
+          "signature": "intersect(s, itrs...) -> Set",
+          "description": "Constructs the intersection of sets, containing only elements common to all arguments.",
+          "type": "method"
+        },
+        "setdiff": {
+          "signature": "setdiff(s, itrs...) -> Set",
+          "description": "Constructs the set of elements in s but not in any of the other iterables.",
+          "type": "method"
+        },
+        "issubset": {
+          "signature": "issubset(a, b) -> Bool",
+          "description": "Determines whether every element of a is also in b.",
+          "type": "method"
+        },
+        "push!": {
+          "signature": "push!(s::Set, x) -> Set",
+          "description": "Adds element x to the set, mutating it in place.",
+          "type": "method"
+        }
+      }
+    },
+    "println": {
+      "signature": "println([io::IO], xs...)",
+      "description": "Prints the textual representation of the arguments to the output stream (defaulting to stdout), followed by a newline character. Each argument is converted to a string via the show function. Multiple arguments are printed consecutively without separators.",
+      "type": "function",
+      "module": "Base"
+    },
+    "typeof": {
+      "signature": "typeof(x) -> DataType",
+      "description": "Returns the concrete type of the value x. This is the leaf type in Julia's type hierarchy and is used for method dispatch, type assertions, and runtime introspection. Combined with supertypes, it reveals the full type ancestry.",
+      "type": "function",
+      "module": "Base"
+    },
+    "struct": {
+      "signature": "struct TypeName fields... end | mutable struct TypeName fields... end",
+      "description": "Declares a composite type with named fields. Immutable structs (the default) are stack-allocated and more efficiently optimized by the compiler. Mutable structs are heap-allocated and allow field reassignment. Both support constructors, type parameters, and abstract supertype declarations.",
+      "type": "keyword",
+      "module": "Base"
+    },
+    "function": {
+      "signature": "function name(args...)::ReturnType body end",
+      "description": "Defines a named function with typed or untyped arguments, optional return type annotation, and a body block. Julia functions support multiple dispatch — defining multiple methods with different argument type signatures that are selected at call time based on the types of all arguments.",
+      "type": "keyword",
+      "module": "Base"
+    },
+    "Channel": {
+      "signature": "Channel{T}(size::Int=0)",
+      "description": "A typed concurrent communication primitive used for passing messages between asynchronous tasks. Channels can be buffered (with a specified size) or unbuffered, and support put!/take! operations for producer-consumer patterns in Julia's cooperative multitasking model.",
+      "type": "class",
+      "module": "Base",
+      "members": {
+        "put!": {
+          "signature": "put!(c::Channel, v) -> Channel",
+          "description": "Appends a value to the channel, blocking if the channel buffer is full until space is available.",
+          "type": "method"
+        },
+        "take!": {
+          "signature": "take!(c::Channel) -> value",
+          "description": "Removes and returns a value from the channel, blocking if empty until a value is available.",
+          "type": "method"
+        },
+        "close": {
+          "signature": "close(c::Channel) -> nothing",
+          "description": "Closes the channel so that no more values can be put into it; existing values can still be taken.",
+          "type": "method"
+        },
+        "isopen": {
+          "signature": "isopen(c::Channel) -> Bool",
+          "description": "Determines whether the channel is still open for putting new values.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}