@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/ruby.json

@@ -0,0 +1,670 @@
+{
+  "language": "ruby",
+  "definitions": {
+    "String": {
+      "signature": "class String",
+      "description": "A String object holds an arbitrary sequence of bytes, typically representing text. Strings are mutable unless frozen. String literals can be created with single quotes, double quotes, heredocs, and percent literals.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "length": {
+          "signature": "str.length -> Integer",
+          "description": "Returns the number of characters in the string. Multibyte characters are counted as single characters.",
+          "returns": "Integer"
+        },
+        "reverse": {
+          "signature": "str.reverse -> String",
+          "description": "Returns a new string with the characters in reverse order.",
+          "returns": "String"
+        },
+        "upcase": {
+          "signature": "str.upcase(*options) -> String",
+          "description": "Returns a copy of the string with all lowercase letters replaced with their uppercase counterparts. Supports Unicode case mapping.",
+          "returns": "String"
+        },
+        "downcase": {
+          "signature": "str.downcase(*options) -> String",
+          "description": "Returns a copy of the string with all uppercase letters replaced with their lowercase counterparts.",
+          "returns": "String"
+        },
+        "capitalize": {
+          "signature": "str.capitalize(*options) -> String",
+          "description": "Returns a copy of the string with the first character converted to uppercase and the remainder to lowercase.",
+          "returns": "String"
+        },
+        "strip": {
+          "signature": "str.strip -> String",
+          "description": "Returns a copy of the string with leading and trailing whitespace removed.",
+          "returns": "String"
+        },
+        "gsub": {
+          "signature": "str.gsub(pattern, replacement) -> String\nstr.gsub(pattern) { |match| block } -> String",
+          "description": "Returns a copy of the string with all occurrences of the pattern substituted. The pattern can be a string or a Regexp.",
+          "returns": "String"
+        },
+        "sub": {
+          "signature": "str.sub(pattern, replacement) -> String\nstr.sub(pattern) { |match| block } -> String",
+          "description": "Returns a copy of the string with the first occurrence of the pattern replaced.",
+          "returns": "String"
+        },
+        "split": {
+          "signature": "str.split(pattern = $;, limit = -1) -> Array",
+          "description": "Divides the string into substrings based on a delimiter, returning an array. Default delimiter is whitespace.",
+          "returns": "Array"
+        },
+        "chars": {
+          "signature": "str.chars -> Array",
+          "description": "Returns an array of characters in the string. Each element is a single-character string.",
+          "returns": "Array"
+        },
+        "include?": {
+          "signature": "str.include?(other_str) -> true or false",
+          "description": "Returns true if the string contains the given substring.",
+          "returns": "Boolean"
+        },
+        "start_with?": {
+          "signature": "str.start_with?(*prefixes) -> true or false",
+          "description": "Returns true if the string starts with any of the given prefixes. Each prefix can be a String or a Regexp.",
+          "returns": "Boolean"
+        },
+        "end_with?": {
+          "signature": "str.end_with?(*suffixes) -> true or false",
+          "description": "Returns true if the string ends with any of the given suffixes.",
+          "returns": "Boolean"
+        },
+        "match?": {
+          "signature": "str.match?(pattern, pos = 0) -> true or false",
+          "description": "Returns true if the string matches the given pattern. Faster than match because it does not create a MatchData object.",
+          "returns": "Boolean"
+        },
+        "scan": {
+          "signature": "str.scan(pattern) -> Array\nstr.scan(pattern) { |match| block } -> String",
+          "description": "Scans the string for all occurrences of the pattern and returns an array of matches.",
+          "returns": "Array"
+        },
+        "tr": {
+          "signature": "str.tr(from_str, to_str) -> String",
+          "description": "Returns a copy of the string with characters in from_str replaced by the corresponding characters in to_str.",
+          "returns": "String"
+        },
+        "to_i": {
+          "signature": "str.to_i(base = 10) -> Integer",
+          "description": "Interprets leading characters of the string as an integer in the given base. Returns 0 if no valid number is found.",
+          "returns": "Integer"
+        },
+        "to_f": {
+          "signature": "str.to_f -> Float",
+          "description": "Interprets leading characters of the string as a floating-point number. Returns 0.0 if no valid number is found.",
+          "returns": "Float"
+        },
+        "to_sym": {
+          "signature": "str.to_sym -> Symbol",
+          "description": "Returns the Symbol corresponding to the string, creating the symbol if it did not previously exist.",
+          "returns": "Symbol"
+        },
+        "encode": {
+          "signature": "str.encode(encoding, **options) -> String",
+          "description": "Returns a copy of the string transcoded to the specified encoding.",
+          "returns": "String"
+        },
+        "freeze": {
+          "signature": "str.freeze -> String",
+          "description": "Freezes the string, preventing further modifications. Returns the frozen string.",
+          "returns": "String"
+        },
+        "replace": {
+          "signature": "str.replace(other_str) -> String",
+          "description": "Replaces the contents and encoding of the string with the corresponding values from other_str.",
+          "returns": "String"
+        },
+        "chomp": {
+          "signature": "str.chomp(separator = $/) -> String",
+          "description": "Returns a new string with the given record separator removed from the end. Default separator is newline.",
+          "returns": "String"
+        },
+        "chop": {
+          "signature": "str.chop -> String",
+          "description": "Returns a new string with the last character removed. If the string ends with \\r\\n, both characters are removed.",
+          "returns": "String"
+        },
+        "center": {
+          "signature": "str.center(width, padstr = ' ') -> String",
+          "description": "Centers the string in a field of the given width, padding with the pad string on both sides.",
+          "returns": "String"
+        },
+        "ljust": {
+          "signature": "str.ljust(width, padstr = ' ') -> String",
+          "description": "Left-justifies the string in a field of the given width, padding on the right with the pad string.",
+          "returns": "String"
+        },
+        "rjust": {
+          "signature": "str.rjust(width, padstr = ' ') -> String",
+          "description": "Right-justifies the string in a field of the given width, padding on the left with the pad string.",
+          "returns": "String"
+        },
+        "squeeze": {
+          "signature": "str.squeeze(*selectors) -> String",
+          "description": "Returns a new string where runs of the same character (matching the optional selectors) are replaced by a single character.",
+          "returns": "String"
+        },
+        "delete": {
+          "signature": "str.delete(*selectors) -> String",
+          "description": "Returns a copy of the string with all characters in the intersection of the given selectors deleted.",
+          "returns": "String"
+        }
+      }
+    },
+    "Array": {
+      "signature": "class Array",
+      "description": "Arrays are ordered, integer-indexed collections of any object. Array indexing starts at 0. A negative index counts from the end. Arrays can contain mixed types and can be nested.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "push": {
+          "signature": "ary.push(*objects) -> Array",
+          "description": "Appends the given object(s) to the end of the array. Returns the array itself, so several pushes may be chained together.",
+          "returns": "Array"
+        },
+        "pop": {
+          "signature": "ary.pop -> object or nil\nary.pop(n) -> Array",
+          "description": "Removes the last element from the array and returns it, or nil if the array is empty. With an argument, removes and returns the last n elements.",
+          "returns": "Object or Array"
+        },
+        "shift": {
+          "signature": "ary.shift -> object or nil\nary.shift(n) -> Array",
+          "description": "Removes the first element and returns it, shifting all other elements down by one. Returns nil if the array is empty.",
+          "returns": "Object or Array"
+        },
+        "unshift": {
+          "signature": "ary.unshift(*objects) -> Array",
+          "description": "Prepends objects to the front of the array, moving other elements upwards.",
+          "returns": "Array"
+        },
+        "first": {
+          "signature": "ary.first -> object or nil\nary.first(n) -> Array",
+          "description": "Returns the first element, or the first n elements as an array.",
+          "returns": "Object or Array"
+        },
+        "last": {
+          "signature": "ary.last -> object or nil\nary.last(n) -> Array",
+          "description": "Returns the last element, or the last n elements as an array.",
+          "returns": "Object or Array"
+        },
+        "length": {
+          "signature": "ary.length -> Integer",
+          "description": "Returns the number of elements in the array. Alias: size.",
+          "returns": "Integer"
+        },
+        "empty?": {
+          "signature": "ary.empty? -> true or false",
+          "description": "Returns true if the array contains no elements.",
+          "returns": "Boolean"
+        },
+        "include?": {
+          "signature": "ary.include?(object) -> true or false",
+          "description": "Returns true if any element equals the given object (using ==).",
+          "returns": "Boolean"
+        },
+        "flatten": {
+          "signature": "ary.flatten(depth = -1) -> Array",
+          "description": "Returns a new array that is a recursive flattening of the original. The optional depth argument limits the recursion depth.",
+          "returns": "Array"
+        },
+        "compact": {
+          "signature": "ary.compact -> Array",
+          "description": "Returns a new array with all nil elements removed.",
+          "returns": "Array"
+        },
+        "uniq": {
+          "signature": "ary.uniq -> Array\nary.uniq { |element| block } -> Array",
+          "description": "Returns a new array with duplicate values removed. If a block is given, uses the block's return value for comparison.",
+          "returns": "Array"
+        },
+        "sort": {
+          "signature": "ary.sort -> Array\nary.sort { |a, b| block } -> Array",
+          "description": "Returns a new array with elements sorted. Without a block, uses <=> for comparison.",
+          "returns": "Array"
+        },
+        "sort_by": {
+          "signature": "ary.sort_by { |element| block } -> Array",
+          "description": "Sorts elements using the values returned by the given block as sort keys.",
+          "returns": "Array"
+        },
+        "reverse": {
+          "signature": "ary.reverse -> Array",
+          "description": "Returns a new array with elements in reverse order.",
+          "returns": "Array"
+        },
+        "each": {
+          "signature": "ary.each { |element| block } -> Array\nary.each -> Enumerator",
+          "description": "Calls the given block once for each element in the array, passing that element as a parameter.",
+          "returns": "Array or Enumerator"
+        },
+        "map": {
+          "signature": "ary.map { |element| block } -> Array\nary.map -> Enumerator",
+          "description": "Returns a new array containing the values returned by the block for each element. Alias: collect.",
+          "returns": "Array or Enumerator"
+        },
+        "select": {
+          "signature": "ary.select { |element| block } -> Array\nary.select -> Enumerator",
+          "description": "Returns a new array containing all elements for which the block returns a truthy value. Alias: filter.",
+          "returns": "Array or Enumerator"
+        },
+        "reject": {
+          "signature": "ary.reject { |element| block } -> Array\nary.reject -> Enumerator",
+          "description": "Returns a new array excluding all elements for which the block returns a truthy value.",
+          "returns": "Array or Enumerator"
+        },
+        "reduce": {
+          "signature": "ary.reduce(initial, sym) -> object\nary.reduce(initial) { |memo, element| block } -> object",
+          "description": "Combines all elements by applying a binary operation, specified by a block or a symbol naming a method. Alias: inject.",
+          "returns": "Object"
+        },
+        "find": {
+          "signature": "ary.find(ifnone = nil) { |element| block } -> object or nil",
+          "description": "Returns the first element for which the block returns truthy, or calls ifnone if no match is found. Alias: detect.",
+          "returns": "Object or nil"
+        },
+        "any?": {
+          "signature": "ary.any? { |element| block } -> true or false\nary.any?(pattern) -> true or false",
+          "description": "Returns true if the block ever returns a truthy value for any element. With a pattern, checks if any element === pattern.",
+          "returns": "Boolean"
+        },
+        "all?": {
+          "signature": "ary.all? { |element| block } -> true or false\nary.all?(pattern) -> true or false",
+          "description": "Returns true if the block returns a truthy value for every element.",
+          "returns": "Boolean"
+        },
+        "none?": {
+          "signature": "ary.none? { |element| block } -> true or false\nary.none?(pattern) -> true or false",
+          "description": "Returns true if the block returns a falsy value for every element.",
+          "returns": "Boolean"
+        },
+        "count": {
+          "signature": "ary.count -> Integer\nary.count(obj) -> Integer\nary.count { |element| block } -> Integer",
+          "description": "Returns the number of elements. With an argument, counts elements equal to the argument. With a block, counts elements for which the block returns truthy.",
+          "returns": "Integer"
+        },
+        "min": {
+          "signature": "ary.min -> object\nary.min(n) -> Array\nary.min { |a, b| block } -> object",
+          "description": "Returns the minimum element, using <=> or the given block for comparison.",
+          "returns": "Object or Array"
+        },
+        "max": {
+          "signature": "ary.max -> object\nary.max(n) -> Array\nary.max { |a, b| block } -> object",
+          "description": "Returns the maximum element, using <=> or the given block for comparison.",
+          "returns": "Object or Array"
+        },
+        "sum": {
+          "signature": "ary.sum(init = 0) -> number\nary.sum(init = 0) { |element| block } -> number",
+          "description": "Returns the sum of elements. With a block, sums the results of running the block for each element.",
+          "returns": "Numeric"
+        },
+        "zip": {
+          "signature": "ary.zip(*other_arrays) -> Array\nary.zip(*other_arrays) { |arr| block } -> nil",
+          "description": "Merges elements of self with corresponding elements from each argument array, returning an array of arrays.",
+          "returns": "Array or nil"
+        },
+        "flat_map": {
+          "signature": "ary.flat_map { |element| block } -> Array",
+          "description": "Returns a new array with the concatenated results of running the block for every element. Equivalent to map then flatten(1).",
+          "returns": "Array"
+        },
+        "each_with_index": {
+          "signature": "ary.each_with_index { |element, index| block } -> Array",
+          "description": "Calls the block with each element and its index.",
+          "returns": "Array or Enumerator"
+        },
+        "group_by": {
+          "signature": "ary.group_by { |element| block } -> Hash",
+          "description": "Groups elements into a hash where keys are the block's return values and values are arrays of corresponding elements.",
+          "returns": "Hash"
+        },
+        "tally": {
+          "signature": "ary.tally -> Hash",
+          "description": "Counts the occurrences of each element and returns a hash. Keys are elements, values are counts.",
+          "returns": "Hash"
+        },
+        "sample": {
+          "signature": "ary.sample -> object or nil\nary.sample(n) -> Array\nary.sample(n, random: rng) -> Array",
+          "description": "Returns a random element or n random elements from the array.",
+          "returns": "Object or Array"
+        },
+        "shuffle": {
+          "signature": "ary.shuffle -> Array\nary.shuffle(random: rng) -> Array",
+          "description": "Returns a new array with elements shuffled in random order.",
+          "returns": "Array"
+        },
+        "join": {
+          "signature": "ary.join(separator = $,) -> String",
+          "description": "Converts each element to a string (via to_s) and joins them with the given separator.",
+          "returns": "String"
+        },
+        "dig": {
+          "signature": "ary.dig(index, *identifiers) -> object or nil",
+          "description": "Extracts the nested value specified by the sequence of indices. Returns nil if any intermediate step is nil.",
+          "returns": "Object or nil"
+        },
+        "take": {
+          "signature": "ary.take(n) -> Array",
+          "description": "Returns the first n elements of the array.",
+          "returns": "Array"
+        },
+        "drop": {
+          "signature": "ary.drop(n) -> Array",
+          "description": "Returns the array minus its first n elements.",
+          "returns": "Array"
+        },
+        "combination": {
+          "signature": "ary.combination(n) { |c| block } -> Array\nary.combination(n) -> Enumerator",
+          "description": "Yields all combinations of length n of elements from the array.",
+          "returns": "Array or Enumerator"
+        },
+        "permutation": {
+          "signature": "ary.permutation(n = self.size) { |p| block } -> Array\nary.permutation(n) -> Enumerator",
+          "description": "Yields all permutations of length n of elements from the array.",
+          "returns": "Array or Enumerator"
+        },
+        "intersection": {
+          "signature": "ary.intersection(*other_arrays) -> Array",
+          "description": "Returns a new array containing elements common to self and all given arrays, removing duplicates. Order is preserved from self.",
+          "returns": "Array"
+        },
+        "union": {
+          "signature": "ary.union(*other_arrays) -> Array",
+          "description": "Returns a new array that is the union of self and all given arrays, removing duplicates. Order is preserved.",
+          "returns": "Array"
+        },
+        "difference": {
+          "signature": "ary.difference(*other_arrays) -> Array",
+          "description": "Returns a new array containing elements from self that are not in any of the given arrays.",
+          "returns": "Array"
+        }
+      }
+    },
+    "Hash": {
+      "signature": "class Hash",
+      "description": "A Hash is a collection of key-value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any type, not integer indices. The order of key-value pairs is the insertion order.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "keys": {
+          "signature": "hsh.keys -> Array",
+          "description": "Returns a new array populated with the keys from the hash.",
+          "returns": "Array"
+        },
+        "values": {
+          "signature": "hsh.values -> Array",
+          "description": "Returns a new array populated with the values from the hash.",
+          "returns": "Array"
+        },
+        "each": {
+          "signature": "hsh.each { |key, value| block } -> Hash\nhsh.each -> Enumerator",
+          "description": "Calls the block once for each key-value pair in the hash, passing the key and value as parameters.",
+          "returns": "Hash or Enumerator"
+        },
+        "map": {
+          "signature": "hsh.map { |key, value| block } -> Array",
+          "description": "Returns a new array with the results of running the block once for every key-value pair.",
+          "returns": "Array"
+        },
+        "select": {
+          "signature": "hsh.select { |key, value| block } -> Hash\nhsh.select -> Enumerator",
+          "description": "Returns a new hash consisting of key-value pairs for which the block returns a truthy value. Alias: filter.",
+          "returns": "Hash or Enumerator"
+        },
+        "reject": {
+          "signature": "hsh.reject { |key, value| block } -> Hash",
+          "description": "Returns a new hash consisting of key-value pairs for which the block returns a falsy value.",
+          "returns": "Hash"
+        },
+        "merge": {
+          "signature": "hsh.merge(*other_hashes) -> Hash\nhsh.merge(*other_hashes) { |key, old_val, new_val| block } -> Hash",
+          "description": "Returns a new hash containing the contents of self and the other hashes. For duplicate keys, the value from the last hash wins, unless a block is given.",
+          "returns": "Hash"
+        },
+        "fetch": {
+          "signature": "hsh.fetch(key) -> value\nhsh.fetch(key, default) -> value\nhsh.fetch(key) { |key| block } -> value",
+          "description": "Returns the value for the given key. If the key is not found, raises KeyError (no default), returns the default value, or calls the block.",
+          "returns": "Object"
+        },
+        "dig": {
+          "signature": "hsh.dig(key, *identifiers) -> object or nil",
+          "description": "Extracts the nested value specified by the sequence of keys. Returns nil if any intermediate step is nil.",
+          "returns": "Object or nil"
+        },
+        "has_key?": {
+          "signature": "hsh.has_key?(key) -> true or false",
+          "description": "Returns true if the given key is present in the hash. Aliases: include?, key?, member?.",
+          "returns": "Boolean"
+        },
+        "delete": {
+          "signature": "hsh.delete(key) -> value or nil\nhsh.delete(key) { |key| block } -> value",
+          "description": "Deletes the key-value pair and returns the value. If the key is not found, returns nil or calls the block.",
+          "returns": "Object or nil"
+        },
+        "transform_keys": {
+          "signature": "hsh.transform_keys { |key| block } -> Hash\nhsh.transform_keys(hash_mapping) -> Hash",
+          "description": "Returns a new hash with keys transformed by the block or mapping. Added in Ruby 2.5.",
+          "returns": "Hash"
+        },
+        "transform_values": {
+          "signature": "hsh.transform_values { |value| block } -> Hash",
+          "description": "Returns a new hash with values transformed by the block.",
+          "returns": "Hash"
+        },
+        "to_a": {
+          "signature": "hsh.to_a -> Array",
+          "description": "Converts the hash to a nested array of [key, value] pairs.",
+          "returns": "Array"
+        },
+        "invert": {
+          "signature": "hsh.invert -> Hash",
+          "description": "Returns a new hash with keys and values swapped. If there are duplicate values, the last one wins.",
+          "returns": "Hash"
+        },
+        "any?": {
+          "signature": "hsh.any? { |key, value| block } -> true or false",
+          "description": "Returns true if the block returns a truthy value for any key-value pair.",
+          "returns": "Boolean"
+        },
+        "all?": {
+          "signature": "hsh.all? { |key, value| block } -> true or false",
+          "description": "Returns true if the block returns a truthy value for every key-value pair.",
+          "returns": "Boolean"
+        },
+        "count": {
+          "signature": "hsh.count -> Integer\nhsh.count { |key, value| block } -> Integer",
+          "description": "Returns the number of key-value pairs. With a block, counts pairs for which the block returns truthy.",
+          "returns": "Integer"
+        },
+        "empty?": {
+          "signature": "hsh.empty? -> true or false",
+          "description": "Returns true if the hash contains no key-value pairs.",
+          "returns": "Boolean"
+        },
+        "slice": {
+          "signature": "hsh.slice(*keys) -> Hash",
+          "description": "Returns a new hash containing only the given keys and their values. Added in Ruby 2.5.",
+          "returns": "Hash"
+        },
+        "except": {
+          "signature": "hsh.except(*keys) -> Hash",
+          "description": "Returns a new hash excluding the specified keys. Added in Ruby 3.0.",
+          "returns": "Hash"
+        }
+      }
+    },
+    "Enumerable": {
+      "signature": "module Enumerable",
+      "description": "The Enumerable mixin provides collection classes with traversal, searching, and sorting methods. The class must provide a method each, which yields successive members of the collection. Many core classes include Enumerable: Array, Hash, Range, Set, etc.",
+      "type": "module",
+      "module": "Core",
+      "members": {
+        "each": {
+          "signature": "enum.each { |element| block } -> enum",
+          "description": "Calls the given block once for each element in the collection. Required method for Enumerable inclusion.",
+          "returns": "Enumerator or self"
+        },
+        "map": {
+          "signature": "enum.map { |element| block } -> Array",
+          "description": "Returns a new array with the results of running the block for every element. Alias: collect.",
+          "returns": "Array"
+        },
+        "select": {
+          "signature": "enum.select { |element| block } -> Array",
+          "description": "Returns an array of all elements for which the block returns a truthy value. Alias: filter.",
+          "returns": "Array"
+        },
+        "reject": {
+          "signature": "enum.reject { |element| block } -> Array",
+          "description": "Returns an array of all elements for which the block returns a falsy value.",
+          "returns": "Array"
+        },
+        "reduce": {
+          "signature": "enum.reduce(initial, sym) -> object\nenum.reduce(initial) { |memo, element| block } -> object",
+          "description": "Combines all elements by applying a binary operation. Alias: inject.",
+          "returns": "Object"
+        },
+        "flat_map": {
+          "signature": "enum.flat_map { |element| block } -> Array",
+          "description": "Returns a new array with the concatenated results of running the block for every element, then flattening one level.",
+          "returns": "Array"
+        },
+        "group_by": {
+          "signature": "enum.group_by { |element| block } -> Hash",
+          "description": "Groups the collection's elements into a hash keyed by the block's return value.",
+          "returns": "Hash"
+        },
+        "sort_by": {
+          "signature": "enum.sort_by { |element| block } -> Array",
+          "description": "Sorts elements by the values returned by the block. Uses a Schwartzian transform internally.",
+          "returns": "Array"
+        },
+        "min_by": {
+          "signature": "enum.min_by { |element| block } -> object\nenum.min_by(n) { |element| block } -> Array",
+          "description": "Returns the element for which the block returns the minimum value.",
+          "returns": "Object or Array"
+        },
+        "max_by": {
+          "signature": "enum.max_by { |element| block } -> object\nenum.max_by(n) { |element| block } -> Array",
+          "description": "Returns the element for which the block returns the maximum value.",
+          "returns": "Object or Array"
+        },
+        "tally": {
+          "signature": "enum.tally -> Hash\nenum.tally_by { |element| block } -> Hash",
+          "description": "Counts occurrences of each element and returns a hash. Added in Ruby 2.7.",
+          "returns": "Hash"
+        },
+        "sum": {
+          "signature": "enum.sum(init = 0) -> number\nenum.sum(init = 0) { |element| block } -> number",
+          "description": "Returns the sum of elements, optionally transformed by a block.",
+          "returns": "Numeric"
+        },
+        "zip": {
+          "signature": "enum.zip(*lists) -> Array",
+          "description": "Takes one element from the enumerable and merges corresponding elements from each argument.",
+          "returns": "Array"
+        },
+        "lazy": {
+          "signature": "enum.lazy -> Enumerator::Lazy",
+          "description": "Returns a lazy enumerator. Transformations are deferred until values are needed, enabling work with infinite sequences.",
+          "returns": "Enumerator::Lazy"
+        },
+        "filter_map": {
+          "signature": "enum.filter_map { |element| block } -> Array",
+          "description": "Returns an array containing the truthy results of running the block for every element. Equivalent to filter + map in one pass. Added in Ruby 2.7.",
+          "returns": "Array"
+        },
+        "each_with_object": {
+          "signature": "enum.each_with_object(obj) { |element, obj| block } -> obj",
+          "description": "Iterates over the collection, passing each element and the given object to the block. Returns the object.",
+          "returns": "Object"
+        },
+        "chunk": {
+          "signature": "enum.chunk { |element| block } -> Enumerator",
+          "description": "Enumerates over items, chunking them together based on consecutive elements that return the same block value.",
+          "returns": "Enumerator"
+        }
+      }
+    },
+    "File": {
+      "signature": "class File < IO",
+      "description": "File is an abstraction of any file object accessible in the underlying operating system. File includes the methods of module FileTest as class methods.",
+      "type": "class",
+      "module": "Core",
+      "members": {
+        "read": {
+          "signature": "File.read(filename, length = nil, offset = 0, **opts) -> String",
+          "description": "Opens the file, optionally seeks to the given offset, reads length bytes (or all if nil), closes the file, and returns the data as a string.",
+          "returns": "String"
+        },
+        "write": {
+          "signature": "File.write(filename, string, offset = nil, **opts) -> Integer",
+          "description": "Opens the file, optionally seeks to the given offset, writes the string, closes the file, and returns the number of bytes written.",
+          "returns": "Integer"
+        },
+        "open": {
+          "signature": "File.open(filename, mode = 'r', **opts) -> File\nFile.open(filename, mode = 'r', **opts) { |f| block } -> object",
+          "description": "With no block, opens the file and returns a File object. With a block, passes the File to the block and ensures the file is closed afterward.",
+          "returns": "File or Object"
+        },
+        "exist?": {
+          "signature": "File.exist?(path) -> true or false",
+          "description": "Returns true if the named file exists. Follows symbolic links.",
+          "returns": "Boolean"
+        },
+        "delete": {
+          "signature": "File.delete(*filenames) -> Integer",
+          "description": "Deletes the named file(s). Returns the number of files deleted. Alias: unlink.",
+          "returns": "Integer"
+        },
+        "rename": {
+          "signature": "File.rename(old_name, new_name) -> 0",
+          "description": "Renames the given file to the new name. Raises SystemCallError on failure.",
+          "returns": "Integer"
+        },
+        "join": {
+          "signature": "File.join(*parts) -> String",
+          "description": "Returns a new string consisting of the parts joined with File::SEPARATOR.",
+          "returns": "String"
+        },
+        "dirname": {
+          "signature": "File.dirname(path, level = 1) -> String",
+          "description": "Returns all components of the filename given in path except the last one.",
+          "returns": "String"
+        },
+        "basename": {
+          "signature": "File.basename(path, suffix = '') -> String",
+          "description": "Returns the last component of the filename. If suffix is given, it is removed from the result.",
+          "returns": "String"
+        },
+        "extname": {
+          "signature": "File.extname(path) -> String",
+          "description": "Returns the extension (the portion of the file name after the last dot, including the dot).",
+          "returns": "String"
+        },
+        "size": {
+          "signature": "File.size(path) -> Integer",
+          "description": "Returns the size of the file in bytes.",
+          "returns": "Integer"
+        },
+        "mtime": {
+          "signature": "File.mtime(path) -> Time",
+          "description": "Returns the modification time of the named file as a Time object.",
+          "returns": "Time"
+        },
+        "directory?": {
+          "signature": "File.directory?(path) -> true or false",
+          "description": "Returns true if the named file is a directory.",
+          "returns": "Boolean"
+        },
+        "file?": {
+          "signature": "File.file?(path) -> true or false",
+          "description": "Returns true if the named file exists and is a regular file.",
+          "returns": "Boolean"
+        }
+      }
+    }
+  }
+}