@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/ruby.json

@@ -0,0 +1,1531 @@
+{
+  "language": "ruby",
+  "completions": [
+    {
+      "label": "puts",
+      "kind": 1,
+      "detail": "Write to stdout with newline",
+      "documentation": { "value": "Writes the given object(s) to STDOUT followed by a newline.\n\n```ruby\nputs 'Hello, World!'\nputs name\nputs \"Value: #{x}\"\n```" },
+      "insertText": "puts ${1:object}",
+      "insertTextRules": 4,
+      "sortText": "00_puts"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Write to stdout without newline",
+      "documentation": { "value": "Prints the given object(s) to STDOUT without a trailing newline.\n\n```ruby\nprint 'Hello '\nprint 'World'\n```" },
+      "insertText": "print ${1:object}",
+      "insertTextRules": 4,
+      "sortText": "00_print"
+    },
+    {
+      "label": "p",
+      "kind": 1,
+      "detail": "Inspect and print object",
+      "documentation": { "value": "Prints the `.inspect` output of the given object(s) followed by a newline. Useful for debugging.\n\n```ruby\np [1, 2, 3]\np variable\n```" },
+      "insertText": "p ${1:object}",
+      "insertTextRules": 4,
+      "sortText": "00_p"
+    },
+    {
+      "label": "pp",
+      "kind": 1,
+      "detail": "Pretty-print object",
+      "documentation": { "value": "Pretty-prints the given object(s) with indentation. Requires `pp` in older Ruby versions.\n\n```ruby\npp({ a: 1, b: [2, 3] })\n```" },
+      "insertText": "pp ${1:object}",
+      "insertTextRules": 4,
+      "sortText": "00_pp"
+    },
+    {
+      "label": "printf",
+      "kind": 1,
+      "detail": "Formatted output to stdout",
+      "documentation": { "value": "Prints a formatted string to STDOUT using format specifiers.\n\n```ruby\nprintf(\"%s is %d years old\\n\", name, age)\nprintf(\"%.2f\\n\", 3.14159)\n```" },
+      "insertText": "printf(\"${1:format}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "00_printf"
+    },
+    {
+      "label": "warn",
+      "kind": 1,
+      "detail": "Write to stderr",
+      "documentation": { "value": "Writes the given message(s) to STDERR.\n\n```ruby\nwarn 'Something went wrong'\nwarn 'Deprecation warning:', msg\n```" },
+      "insertText": "warn \"${1:message}\"",
+      "insertTextRules": 4,
+      "sortText": "00_warn"
+    },
+    {
+      "label": "STDOUT.write",
+      "kind": 1,
+      "detail": "Write bytes to stdout",
+      "documentation": { "value": "Writes the given string directly to STDOUT. Returns the number of bytes written.\n\n```ruby\nSTDOUT.write('hello')\n```" },
+      "insertText": "STDOUT.write(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "00_stdout_write"
+    },
+    {
+      "label": "def",
+      "kind": 14,
+      "detail": "Define a method",
+      "documentation": { "value": "Defines a new method.\n\n```ruby\ndef greet(name)\n  \"Hello, #{name}!\"\nend\n```" },
+      "insertText": "def ${1:method_name}(${2:args})\n  ${3:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "01_def"
+    },
+    {
+      "label": "class",
+      "kind": 14,
+      "detail": "Define a class",
+      "documentation": { "value": "Defines a new class.\n\n```ruby\nclass MyClass < BaseClass\n  def initialize\n  end\nend\n```" },
+      "insertText": "class ${1:ClassName}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "01_class"
+    },
+    {
+      "label": "module",
+      "kind": 14,
+      "detail": "Define a module",
+      "documentation": { "value": "Defines a new module for namespacing or mixins.\n\n```ruby\nmodule MyModule\n  def helper\n  end\nend\n```" },
+      "insertText": "module ${1:ModuleName}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "01_module"
+    },
+    {
+      "label": "include",
+      "kind": 14,
+      "detail": "Include a module as instance methods",
+      "documentation": { "value": "Includes a module's methods as instance methods in the current class.\n\n```ruby\nclass MyClass\n  include Comparable\nend\n```" },
+      "insertText": "include ${1:ModuleName}",
+      "insertTextRules": 4,
+      "sortText": "01_include"
+    },
+    {
+      "label": "extend",
+      "kind": 14,
+      "detail": "Extend with module as class methods",
+      "documentation": { "value": "Adds a module's methods as class methods to the current class or object.\n\n```ruby\nclass MyClass\n  extend ClassMethods\nend\n```" },
+      "insertText": "extend ${1:ModuleName}",
+      "insertTextRules": 4,
+      "sortText": "01_extend"
+    },
+    {
+      "label": "prepend",
+      "kind": 14,
+      "detail": "Prepend a module",
+      "documentation": { "value": "Prepends a module, inserting it before the class in the method lookup chain.\n\n```ruby\nclass MyClass\n  prepend Logging\nend\n```" },
+      "insertText": "prepend ${1:ModuleName}",
+      "insertTextRules": 4,
+      "sortText": "01_prepend"
+    },
+    {
+      "label": "require",
+      "kind": 14,
+      "detail": "Load an external library",
+      "documentation": { "value": "Loads the given library or gem. Searches `$LOAD_PATH`.\n\n```ruby\nrequire 'json'\nrequire 'net/http'\n```" },
+      "insertText": "require '${1:library}'",
+      "insertTextRules": 4,
+      "sortText": "01_require"
+    },
+    {
+      "label": "require_relative",
+      "kind": 14,
+      "detail": "Load a file relative to current file",
+      "documentation": { "value": "Loads a file relative to the directory of the current file.\n\n```ruby\nrequire_relative 'helpers/utils'\n```" },
+      "insertText": "require_relative '${1:path}'",
+      "insertTextRules": 4,
+      "sortText": "01_require_relative"
+    },
+    {
+      "label": "attr_accessor",
+      "kind": 14,
+      "detail": "Define getter and setter",
+      "documentation": { "value": "Creates getter and setter methods for the given attribute(s).\n\n```ruby\nclass Person\n  attr_accessor :name, :age\nend\n```" },
+      "insertText": "attr_accessor :${1:attribute}",
+      "insertTextRules": 4,
+      "sortText": "01_attr_accessor"
+    },
+    {
+      "label": "attr_reader",
+      "kind": 14,
+      "detail": "Define getter only",
+      "documentation": { "value": "Creates getter methods for the given attribute(s).\n\n```ruby\nclass Person\n  attr_reader :name\nend\n```" },
+      "insertText": "attr_reader :${1:attribute}",
+      "insertTextRules": 4,
+      "sortText": "01_attr_reader"
+    },
+    {
+      "label": "attr_writer",
+      "kind": 14,
+      "detail": "Define setter only",
+      "documentation": { "value": "Creates setter methods for the given attribute(s).\n\n```ruby\nclass Person\n  attr_writer :name\nend\n```" },
+      "insertText": "attr_writer :${1:attribute}",
+      "insertTextRules": 4,
+      "sortText": "01_attr_writer"
+    },
+    {
+      "label": "begin/rescue/ensure/end",
+      "kind": 14,
+      "detail": "Exception handling block",
+      "documentation": { "value": "Handles exceptions with rescue and optional ensure cleanup.\n\n```ruby\nbegin\n  risky_operation\nrescue StandardError => e\n  puts e.message\nensure\n  cleanup\nend\n```" },
+      "insertText": "begin\n  ${1:# code}\nrescue ${2:StandardError} => ${3:e}\n  ${4:puts e.message}\nensure\n  ${5:# cleanup}\nend",
+      "insertTextRules": 4,
+      "sortText": "01_begin_rescue"
+    },
+    {
+      "label": "raise",
+      "kind": 14,
+      "detail": "Raise an exception",
+      "documentation": { "value": "Raises an exception. Can specify exception class and message.\n\n```ruby\nraise 'Something went wrong'\nraise ArgumentError, 'Invalid input'\nraise CustomError.new('msg')\n```" },
+      "insertText": "raise ${1:RuntimeError}, '${2:message}'",
+      "insertTextRules": 4,
+      "sortText": "01_raise"
+    },
+    {
+      "label": "yield",
+      "kind": 14,
+      "detail": "Yield to a block",
+      "documentation": { "value": "Passes control to the block given to the current method.\n\n```ruby\ndef with_logging\n  puts 'Start'\n  yield\n  puts 'End'\nend\n```" },
+      "insertText": "yield${1: ${2:args}}",
+      "insertTextRules": 4,
+      "sortText": "01_yield"
+    },
+    {
+      "label": "block_given?",
+      "kind": 1,
+      "detail": "Check if a block was passed",
+      "documentation": { "value": "Returns `true` if the current method was called with a block.\n\n```ruby\ndef maybe_yield\n  yield if block_given?\nend\n```" },
+      "insertText": "block_given?",
+      "insertTextRules": 4,
+      "sortText": "01_block_given"
+    },
+    {
+      "label": "return",
+      "kind": 14,
+      "detail": "Return from method",
+      "documentation": { "value": "Returns a value from the current method. Implicit return of last expression is idiomatic Ruby.\n\n```ruby\ndef add(a, b)\n  return a + b\nend\n```" },
+      "insertText": "return ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "01_return"
+    },
+    {
+      "label": "lambda",
+      "kind": 1,
+      "detail": "Create a lambda",
+      "documentation": { "value": "Creates a lambda (strict Proc). Checks argument count and `return` exits the lambda only.\n\n```ruby\nadd = lambda { |a, b| a + b }\nadd.call(1, 2)\n```" },
+      "insertText": "lambda { |${1:args}| ${2:body} }",
+      "insertTextRules": 4,
+      "sortText": "01_lambda"
+    },
+    {
+      "label": "proc",
+      "kind": 1,
+      "detail": "Create a proc",
+      "documentation": { "value": "Creates a Proc object from a block.\n\n```ruby\ndouble = proc { |x| x * 2 }\ndouble.call(5) # => 10\n```" },
+      "insertText": "proc { |${1:args}| ${2:body} }",
+      "insertTextRules": 4,
+      "sortText": "01_proc"
+    },
+    {
+      "label": "Proc.new",
+      "kind": 1,
+      "detail": "Create a Proc object",
+      "documentation": { "value": "Creates a new Proc object from a block.\n\n```ruby\np = Proc.new { |x| x * 2 }\np.call(5)\n```" },
+      "insertText": "Proc.new { |${1:args}| ${2:body} }",
+      "insertTextRules": 4,
+      "sortText": "01_proc_new"
+    },
+    {
+      "label": "->",
+      "kind": 1,
+      "detail": "Lambda literal (stabby lambda)",
+      "documentation": { "value": "Creates a lambda using the stabby lambda syntax.\n\n```ruby\nadd = ->(a, b) { a + b }\nadd.call(1, 2)\n```" },
+      "insertText": "->(${1:args}) { ${2:body} }",
+      "insertTextRules": 4,
+      "sortText": "01_stabby_lambda"
+    },
+    {
+      "label": "do..end",
+      "kind": 14,
+      "detail": "Block with do..end",
+      "documentation": { "value": "Multi-line block syntax.\n\n```ruby\n[1, 2, 3].each do |item|\n  puts item\nend\n```" },
+      "insertText": "do |${1:var}|\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "01_do_end"
+    },
+    {
+      "label": "if",
+      "kind": 14,
+      "detail": "Conditional if statement",
+      "documentation": { "value": "Executes code if the condition is true.\n\n```ruby\nif condition\n  # do something\nelsif other\n  # alternative\nelse\n  # default\nend\n```" },
+      "insertText": "if ${1:condition}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_if"
+    },
+    {
+      "label": "unless",
+      "kind": 14,
+      "detail": "Negated conditional",
+      "documentation": { "value": "Executes code if the condition is false.\n\n```ruby\nunless logged_in?\n  redirect_to login_path\nend\n```" },
+      "insertText": "unless ${1:condition}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_unless"
+    },
+    {
+      "label": "case/when",
+      "kind": 14,
+      "detail": "Case/when expression",
+      "documentation": { "value": "Pattern matching with case/when.\n\n```ruby\ncase value\nwhen 1\n  'one'\nwhen 2..5\n  'two to five'\nelse\n  'other'\nend\n```" },
+      "insertText": "case ${1:expression}\nwhen ${2:value}\n  ${3:# body}\nelse\n  ${4:# default}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_case_when"
+    },
+    {
+      "label": "case/in",
+      "kind": 14,
+      "detail": "Pattern matching (Ruby 3+)",
+      "documentation": { "value": "Structural pattern matching introduced in Ruby 2.7+.\n\n```ruby\ncase data\nin { name: String => name, age: (18..) => age }\n  puts \"#{name}, #{age}\"\nin [Integer => x, Integer => y]\n  puts x + y\nend\n```" },
+      "insertText": "case ${1:expression}\nin ${2:pattern}\n  ${3:# body}\nelse\n  ${4:# default}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_case_in"
+    },
+    {
+      "label": "while",
+      "kind": 14,
+      "detail": "While loop",
+      "documentation": { "value": "Executes code while the condition is true.\n\n```ruby\nwhile condition\n  # loop body\nend\n```" },
+      "insertText": "while ${1:condition}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_while"
+    },
+    {
+      "label": "until",
+      "kind": 14,
+      "detail": "Until loop",
+      "documentation": { "value": "Executes code until the condition becomes true.\n\n```ruby\nuntil done?\n  process_next\nend\n```" },
+      "insertText": "until ${1:condition}\n  ${2:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_until"
+    },
+    {
+      "label": "for..in",
+      "kind": 14,
+      "detail": "For loop",
+      "documentation": { "value": "Iterates over a collection. Prefer `.each` in idiomatic Ruby.\n\n```ruby\nfor item in collection\n  puts item\nend\n```" },
+      "insertText": "for ${1:item} in ${2:collection}\n  ${3:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "02_for_in"
+    },
+    {
+      "label": "break",
+      "kind": 14,
+      "detail": "Break out of a loop",
+      "documentation": { "value": "Terminates the most internal loop or block.\n\n```ruby\nloop do\n  break if condition\nend\n```" },
+      "insertText": "break",
+      "sortText": "02_break"
+    },
+    {
+      "label": "next",
+      "kind": 14,
+      "detail": "Skip to next iteration",
+      "documentation": { "value": "Skips to the next iteration of a loop or block.\n\n```ruby\n[1, 2, 3].each do |n|\n  next if n.even?\n  puts n\nend\n```" },
+      "insertText": "next",
+      "sortText": "02_next"
+    },
+    {
+      "label": "redo",
+      "kind": 14,
+      "detail": "Restart current iteration",
+      "documentation": { "value": "Restarts the current iteration of a loop without re-evaluating the condition.\n\n```ruby\nattempts = 0\nloop do\n  attempts += 1\n  redo if attempts < 3\n  break\nend\n```" },
+      "insertText": "redo",
+      "sortText": "02_redo"
+    },
+    {
+      "label": "retry",
+      "kind": 14,
+      "detail": "Retry from begin block",
+      "documentation": { "value": "Restarts execution from the beginning of a `begin` block. Used in rescue clauses.\n\n```ruby\nbegin\n  connect\nrescue ConnectionError\n  retry\nend\n```" },
+      "insertText": "retry",
+      "sortText": "02_retry"
+    },
+    {
+      "label": "super",
+      "kind": 14,
+      "detail": "Call parent method",
+      "documentation": { "value": "Calls the same method in the parent class. Without arguments, passes the current method's arguments.\n\n```ruby\ndef initialize(name)\n  super(name)\nend\n```" },
+      "insertText": "super",
+      "sortText": "01_super"
+    },
+    {
+      "label": "self",
+      "kind": 14,
+      "detail": "Reference to current object",
+      "documentation": { "value": "Refers to the current object (receiver of the current method).\n\n```ruby\ndef name=(value)\n  self.name = value\nend\n```" },
+      "insertText": "self",
+      "sortText": "01_self"
+    },
+    {
+      "label": "defined?",
+      "kind": 14,
+      "detail": "Check if expression is defined",
+      "documentation": { "value": "Returns a string describing the expression, or `nil` if not defined.\n\n```ruby\ndefined?(foo)       # => nil or \"local-variable\"\ndefined?(String)    # => \"constant\"\n```" },
+      "insertText": "defined?(${1:expression})",
+      "insertTextRules": 4,
+      "sortText": "01_defined"
+    },
+    {
+      "label": "alias",
+      "kind": 14,
+      "detail": "Create method alias",
+      "documentation": { "value": "Creates an alias for a method.\n\n```ruby\nalias new_name old_name\nalias_method :new_name, :old_name\n```" },
+      "insertText": "alias ${1:new_name} ${2:old_name}",
+      "insertTextRules": 4,
+      "sortText": "01_alias"
+    },
+    {
+      "label": "freeze",
+      "kind": 2,
+      "detail": "Freeze an object",
+      "documentation": { "value": "Prevents further modifications to an object. Returns the frozen object.\n\n```ruby\nstr = 'hello'.freeze\nCONSTANT = [1, 2, 3].freeze\n```" },
+      "insertText": "freeze",
+      "sortText": "01_freeze"
+    },
+    {
+      "label": "frozen?",
+      "kind": 2,
+      "detail": "Check if object is frozen",
+      "documentation": { "value": "Returns `true` if the object is frozen.\n\n```ruby\n'hello'.freeze.frozen? # => true\n```" },
+      "insertText": "frozen?",
+      "sortText": "01_frozen"
+    },
+    {
+      "label": ".length",
+      "kind": 2,
+      "detail": "String/Array length",
+      "documentation": { "value": "Returns the number of characters in a string or elements in an array.\n\n```ruby\n'hello'.length  # => 5\n[1, 2, 3].length # => 3\n```" },
+      "insertText": ".length",
+      "sortText": "03_length"
+    },
+    {
+      "label": ".size",
+      "kind": 2,
+      "detail": "Alias for length",
+      "documentation": { "value": "Returns the count of characters (String) or elements (Array/Hash). Alias for `.length`.\n\n```ruby\n'hello'.size  # => 5\n[1, 2].size   # => 2\n```" },
+      "insertText": ".size",
+      "sortText": "03_size"
+    },
+    {
+      "label": ".reverse",
+      "kind": 2,
+      "detail": "Reverse a string or array",
+      "documentation": { "value": "Returns a new string/array with elements in reverse order.\n\n```ruby\n'hello'.reverse  # => \"olleh\"\n[1, 2, 3].reverse # => [3, 2, 1]\n```" },
+      "insertText": ".reverse",
+      "sortText": "03_reverse"
+    },
+    {
+      "label": ".upcase",
+      "kind": 2,
+      "detail": "Convert to uppercase",
+      "documentation": { "value": "Returns a copy of the string with all lowercase letters replaced with uppercase.\n\n```ruby\n'hello'.upcase  # => \"HELLO\"\n```" },
+      "insertText": ".upcase",
+      "sortText": "03_upcase"
+    },
+    {
+      "label": ".downcase",
+      "kind": 2,
+      "detail": "Convert to lowercase",
+      "documentation": { "value": "Returns a copy of the string with all uppercase letters replaced with lowercase.\n\n```ruby\n'HELLO'.downcase  # => \"hello\"\n```" },
+      "insertText": ".downcase",
+      "sortText": "03_downcase"
+    },
+    {
+      "label": ".capitalize",
+      "kind": 2,
+      "detail": "Capitalize first character",
+      "documentation": { "value": "Returns a copy with the first character uppercased and the rest lowercased.\n\n```ruby\n'hello world'.capitalize  # => \"Hello world\"\n```" },
+      "insertText": ".capitalize",
+      "sortText": "03_capitalize"
+    },
+    {
+      "label": ".strip",
+      "kind": 2,
+      "detail": "Remove leading/trailing whitespace",
+      "documentation": { "value": "Returns a copy with leading and trailing whitespace removed.\n\n```ruby\n'  hello  '.strip  # => \"hello\"\n```" },
+      "insertText": ".strip",
+      "sortText": "03_strip"
+    },
+    {
+      "label": ".lstrip",
+      "kind": 2,
+      "detail": "Remove leading whitespace",
+      "documentation": { "value": "Returns a copy with leading whitespace removed.\n\n```ruby\n'  hello'.lstrip  # => \"hello\"\n```" },
+      "insertText": ".lstrip",
+      "sortText": "03_lstrip"
+    },
+    {
+      "label": ".rstrip",
+      "kind": 2,
+      "detail": "Remove trailing whitespace",
+      "documentation": { "value": "Returns a copy with trailing whitespace removed.\n\n```ruby\n'hello  '.rstrip  # => \"hello\"\n```" },
+      "insertText": ".rstrip",
+      "sortText": "03_rstrip"
+    },
+    {
+      "label": ".chomp",
+      "kind": 2,
+      "detail": "Remove trailing newline",
+      "documentation": { "value": "Returns a new string with the trailing record separator removed (default `\\n`).\n\n```ruby\n\"hello\\n\".chomp  # => \"hello\"\n```" },
+      "insertText": ".chomp",
+      "sortText": "03_chomp"
+    },
+    {
+      "label": ".chop",
+      "kind": 2,
+      "detail": "Remove last character",
+      "documentation": { "value": "Returns a new string with the last character removed.\n\n```ruby\n'hello'.chop  # => \"hell\"\n```" },
+      "insertText": ".chop",
+      "sortText": "03_chop"
+    },
+    {
+      "label": ".gsub",
+      "kind": 2,
+      "detail": "Global substitution",
+      "documentation": { "value": "Returns a copy with all occurrences of the pattern replaced.\n\n```ruby\n'hello'.gsub('l', 'r')       # => \"herro\"\n'hello'.gsub(/[aeiou]/, '*') # => \"h*ll*\"\n```" },
+      "insertText": ".gsub(${1:pattern}, ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "03_gsub"
+    },
+    {
+      "label": ".sub",
+      "kind": 2,
+      "detail": "Substitute first occurrence",
+      "documentation": { "value": "Returns a copy with the first occurrence of the pattern replaced.\n\n```ruby\n'hello'.sub('l', 'r')  # => \"herlo\"\n```" },
+      "insertText": ".sub(${1:pattern}, ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "03_sub"
+    },
+    {
+      "label": ".replace",
+      "kind": 2,
+      "detail": "Replace entire string contents",
+      "documentation": { "value": "Replaces the contents of the string with the given other string.\n\n```ruby\ns = 'hello'\ns.replace('world')  # s is now \"world\"\n```" },
+      "insertText": ".replace(${1:other_string})",
+      "insertTextRules": 4,
+      "sortText": "03_replace"
+    },
+    {
+      "label": ".split",
+      "kind": 2,
+      "detail": "Split string into array",
+      "documentation": { "value": "Divides the string into substrings based on a delimiter and returns an array.\n\n```ruby\n'a,b,c'.split(',')    # => [\"a\", \"b\", \"c\"]\n'hello world'.split   # => [\"hello\", \"world\"]\n```" },
+      "insertText": ".split(${1:delimiter})",
+      "insertTextRules": 4,
+      "sortText": "03_split"
+    },
+    {
+      "label": ".chars",
+      "kind": 2,
+      "detail": "Convert string to character array",
+      "documentation": { "value": "Returns an array of characters in the string.\n\n```ruby\n'hello'.chars  # => [\"h\", \"e\", \"l\", \"l\", \"o\"]\n```" },
+      "insertText": ".chars",
+      "sortText": "03_chars"
+    },
+    {
+      "label": ".bytes",
+      "kind": 2,
+      "detail": "Get byte array",
+      "documentation": { "value": "Returns an array of bytes for the string.\n\n```ruby\n'hello'.bytes  # => [104, 101, 108, 108, 111]\n```" },
+      "insertText": ".bytes",
+      "sortText": "03_bytes"
+    },
+    {
+      "label": ".include?",
+      "kind": 2,
+      "detail": "Check membership",
+      "documentation": { "value": "Returns `true` if the string contains the given substring, or the array contains the given element.\n\n```ruby\n'hello'.include?('ell')  # => true\n[1, 2, 3].include?(2)   # => true\n```" },
+      "insertText": ".include?(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "03_include"
+    },
+    {
+      "label": ".start_with?",
+      "kind": 2,
+      "detail": "Check string prefix",
+      "documentation": { "value": "Returns `true` if the string starts with the given prefix.\n\n```ruby\n'hello'.start_with?('hel')  # => true\n```" },
+      "insertText": ".start_with?(${1:prefix})",
+      "insertTextRules": 4,
+      "sortText": "03_start_with"
+    },
+    {
+      "label": ".end_with?",
+      "kind": 2,
+      "detail": "Check string suffix",
+      "documentation": { "value": "Returns `true` if the string ends with the given suffix.\n\n```ruby\n'hello'.end_with?('llo')  # => true\n```" },
+      "insertText": ".end_with?(${1:suffix})",
+      "insertTextRules": 4,
+      "sortText": "03_end_with"
+    },
+    {
+      "label": ".match?",
+      "kind": 2,
+      "detail": "Test regex match",
+      "documentation": { "value": "Returns `true` if the string matches the given regex. Faster than `match` as it doesn't create a MatchData object.\n\n```ruby\n'hello'.match?(/\\w+/)  # => true\n```" },
+      "insertText": ".match?(${1:pattern})",
+      "insertTextRules": 4,
+      "sortText": "03_match"
+    },
+    {
+      "label": ".scan",
+      "kind": 2,
+      "detail": "Scan for all matches",
+      "documentation": { "value": "Returns an array of all matches of the pattern in the string.\n\n```ruby\n'hello world'.scan(/\\w+/)  # => [\"hello\", \"world\"]\n'a1b2c3'.scan(/\\d+/)      # => [\"1\", \"2\", \"3\"]\n```" },
+      "insertText": ".scan(${1:pattern})",
+      "insertTextRules": 4,
+      "sortText": "03_scan"
+    },
+    {
+      "label": ".tr",
+      "kind": 2,
+      "detail": "Transliterate characters",
+      "documentation": { "value": "Returns a copy with characters in the first argument replaced by corresponding characters in the second.\n\n```ruby\n'hello'.tr('el', 'ip')  # => \"hippo\"\n'hello'.tr('aeiou', '*') # => \"h*ll*\"\n```" },
+      "insertText": ".tr('${1:from}', '${2:to}')",
+      "insertTextRules": 4,
+      "sortText": "03_tr"
+    },
+    {
+      "label": ".squeeze",
+      "kind": 2,
+      "detail": "Remove consecutive duplicate characters",
+      "documentation": { "value": "Returns a new string with runs of the same character replaced by a single character.\n\n```ruby\n'aaabbbccc'.squeeze        # => \"abc\"\n'aabbcc'.squeeze('a')      # => \"abbcc\"\n```" },
+      "insertText": ".squeeze",
+      "sortText": "03_squeeze"
+    },
+    {
+      "label": ".center",
+      "kind": 2,
+      "detail": "Center string in width",
+      "documentation": { "value": "Centers the string in a field of the given width, padding with the given character.\n\n```ruby\n'hi'.center(10)        # => \"    hi    \"\n'hi'.center(10, '-')   # => \"----hi----\"\n```" },
+      "insertText": ".center(${1:width})",
+      "insertTextRules": 4,
+      "sortText": "03_center"
+    },
+    {
+      "label": ".ljust",
+      "kind": 2,
+      "detail": "Left-justify string",
+      "documentation": { "value": "Left-justifies the string in a field of the given width.\n\n```ruby\n'hi'.ljust(10)       # => \"hi        \"\n'hi'.ljust(10, '.')  # => \"hi........\"\n```" },
+      "insertText": ".ljust(${1:width})",
+      "insertTextRules": 4,
+      "sortText": "03_ljust"
+    },
+    {
+      "label": ".rjust",
+      "kind": 2,
+      "detail": "Right-justify string",
+      "documentation": { "value": "Right-justifies the string in a field of the given width.\n\n```ruby\n'hi'.rjust(10)       # => \"        hi\"\n'hi'.rjust(10, '0')  # => \"00000000hi\"\n```" },
+      "insertText": ".rjust(${1:width})",
+      "insertTextRules": 4,
+      "sortText": "03_rjust"
+    },
+    {
+      "label": ".encode",
+      "kind": 2,
+      "detail": "Encode string to encoding",
+      "documentation": { "value": "Returns a copy of the string transcoded to the given encoding.\n\n```ruby\nstr.encode('UTF-8')\nstr.encode('ASCII', invalid: :replace)\n```" },
+      "insertText": ".encode('${1:encoding}')",
+      "insertTextRules": 4,
+      "sortText": "03_encode"
+    },
+    {
+      "label": ".to_i",
+      "kind": 2,
+      "detail": "Convert to integer",
+      "documentation": { "value": "Converts the string to an integer. Leading whitespace is ignored, trailing non-numeric characters are ignored.\n\n```ruby\n'42'.to_i    # => 42\n'0xff'.to_i(16) # => 255\n```" },
+      "insertText": ".to_i",
+      "sortText": "03_to_i"
+    },
+    {
+      "label": ".to_f",
+      "kind": 2,
+      "detail": "Convert to float",
+      "documentation": { "value": "Converts the string to a floating-point number.\n\n```ruby\n'3.14'.to_f  # => 3.14\n```" },
+      "insertText": ".to_f",
+      "sortText": "03_to_f"
+    },
+    {
+      "label": ".to_sym",
+      "kind": 2,
+      "detail": "Convert to symbol",
+      "documentation": { "value": "Returns the symbol corresponding to the string.\n\n```ruby\n'hello'.to_sym  # => :hello\n```" },
+      "insertText": ".to_sym",
+      "sortText": "03_to_sym"
+    },
+    {
+      "label": ".to_s",
+      "kind": 2,
+      "detail": "Convert to string",
+      "documentation": { "value": "Returns the string representation of the object.\n\n```ruby\n42.to_s       # => \"42\"\n:hello.to_s   # => \"hello\"\n```" },
+      "insertText": ".to_s",
+      "sortText": "03_to_s"
+    },
+    {
+      "label": ".push",
+      "kind": 2,
+      "detail": "Append to array",
+      "documentation": { "value": "Appends the given object(s) to the end of the array. Returns the array.\n\n```ruby\narr = [1, 2]\narr.push(3)      # => [1, 2, 3]\narr.push(4, 5)   # => [1, 2, 3, 4, 5]\n```" },
+      "insertText": ".push(${1:element})",
+      "insertTextRules": 4,
+      "sortText": "04_push"
+    },
+    {
+      "label": ".pop",
+      "kind": 2,
+      "detail": "Remove last element",
+      "documentation": { "value": "Removes and returns the last element of the array.\n\n```ruby\narr = [1, 2, 3]\narr.pop  # => 3, arr is [1, 2]\n```" },
+      "insertText": ".pop",
+      "sortText": "04_pop"
+    },
+    {
+      "label": ".shift",
+      "kind": 2,
+      "detail": "Remove first element",
+      "documentation": { "value": "Removes and returns the first element of the array.\n\n```ruby\narr = [1, 2, 3]\narr.shift  # => 1, arr is [2, 3]\n```" },
+      "insertText": ".shift",
+      "sortText": "04_shift"
+    },
+    {
+      "label": ".unshift",
+      "kind": 2,
+      "detail": "Prepend to array",
+      "documentation": { "value": "Prepends the given object(s) to the front of the array.\n\n```ruby\narr = [2, 3]\narr.unshift(1)  # => [1, 2, 3]\n```" },
+      "insertText": ".unshift(${1:element})",
+      "insertTextRules": 4,
+      "sortText": "04_unshift"
+    },
+    {
+      "label": ".first",
+      "kind": 2,
+      "detail": "Get first element(s)",
+      "documentation": { "value": "Returns the first element, or the first `n` elements.\n\n```ruby\n[1, 2, 3].first     # => 1\n[1, 2, 3].first(2)  # => [1, 2]\n```" },
+      "insertText": ".first",
+      "sortText": "04_first"
+    },
+    {
+      "label": ".last",
+      "kind": 2,
+      "detail": "Get last element(s)",
+      "documentation": { "value": "Returns the last element, or the last `n` elements.\n\n```ruby\n[1, 2, 3].last     # => 3\n[1, 2, 3].last(2)  # => [2, 3]\n```" },
+      "insertText": ".last",
+      "sortText": "04_last"
+    },
+    {
+      "label": ".empty?",
+      "kind": 2,
+      "detail": "Check if empty",
+      "documentation": { "value": "Returns `true` if the string, array, or hash has no elements.\n\n```ruby\n[].empty?     # => true\n''.empty?     # => true\n{}.empty?     # => true\n```" },
+      "insertText": ".empty?",
+      "sortText": "04_empty"
+    },
+    {
+      "label": ".flatten",
+      "kind": 2,
+      "detail": "Flatten nested arrays",
+      "documentation": { "value": "Returns a new array that is a one-dimensional flattening of the original.\n\n```ruby\n[[1, 2], [3, [4]]].flatten    # => [1, 2, 3, 4]\n[[1, [2]], [3]].flatten(1)    # => [1, [2], 3]\n```" },
+      "insertText": ".flatten",
+      "sortText": "04_flatten"
+    },
+    {
+      "label": ".compact",
+      "kind": 2,
+      "detail": "Remove nil values",
+      "documentation": { "value": "Returns a new array with all `nil` elements removed.\n\n```ruby\n[1, nil, 2, nil, 3].compact  # => [1, 2, 3]\n```" },
+      "insertText": ".compact",
+      "sortText": "04_compact"
+    },
+    {
+      "label": ".uniq",
+      "kind": 2,
+      "detail": "Remove duplicates",
+      "documentation": { "value": "Returns a new array with duplicate values removed.\n\n```ruby\n[1, 2, 2, 3, 3].uniq  # => [1, 2, 3]\n```" },
+      "insertText": ".uniq",
+      "sortText": "04_uniq"
+    },
+    {
+      "label": ".sort",
+      "kind": 2,
+      "detail": "Sort elements",
+      "documentation": { "value": "Returns a new array with elements sorted. Uses `<=>` by default.\n\n```ruby\n[3, 1, 2].sort              # => [1, 2, 3]\n['b', 'a', 'c'].sort        # => [\"a\", \"b\", \"c\"]\n[3, 1, 2].sort { |a, b| b <=> a }  # => [3, 2, 1]\n```" },
+      "insertText": ".sort",
+      "sortText": "04_sort"
+    },
+    {
+      "label": ".sort_by",
+      "kind": 2,
+      "detail": "Sort by block result",
+      "documentation": { "value": "Sorts elements using the values returned by the block.\n\n```ruby\nwords.sort_by { |w| w.length }\nusers.sort_by(&:name)\n```" },
+      "insertText": ".sort_by { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_sort_by"
+    },
+    {
+      "label": ".each",
+      "kind": 2,
+      "detail": "Iterate over elements",
+      "documentation": { "value": "Calls the given block once for each element.\n\n```ruby\n[1, 2, 3].each { |n| puts n }\n{ a: 1 }.each { |k, v| puts \"#{k}: #{v}\" }\n```" },
+      "insertText": ".each { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_each"
+    },
+    {
+      "label": ".map",
+      "kind": 2,
+      "detail": "Transform elements",
+      "documentation": { "value": "Returns a new array with the results of running the block for every element.\n\n```ruby\n[1, 2, 3].map { |n| n * 2 }    # => [2, 4, 6]\n['a', 'b'].map(&:upcase)        # => [\"A\", \"B\"]\n```" },
+      "insertText": ".map { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_map"
+    },
+    {
+      "label": ".collect",
+      "kind": 2,
+      "detail": "Transform elements (alias for map)",
+      "documentation": { "value": "Alias for `.map`. Returns a new array with block results.\n\n```ruby\n[1, 2, 3].collect { |n| n * 2 }  # => [2, 4, 6]\n```" },
+      "insertText": ".collect { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_collect"
+    },
+    {
+      "label": ".select",
+      "kind": 2,
+      "detail": "Filter elements (keep truthy)",
+      "documentation": { "value": "Returns a new array/hash containing elements for which the block returns a truthy value.\n\n```ruby\n[1, 2, 3, 4].select { |n| n.even? }  # => [2, 4]\n{ a: 1, b: 2 }.select { |k, v| v > 1 }  # => { b: 2 }\n```" },
+      "insertText": ".select { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_select"
+    },
+    {
+      "label": ".filter",
+      "kind": 2,
+      "detail": "Filter elements (alias for select)",
+      "documentation": { "value": "Alias for `.select`. Returns elements for which the block returns truthy.\n\n```ruby\n[1, 2, 3, 4].filter(&:odd?)  # => [1, 3]\n```" },
+      "insertText": ".filter { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_filter"
+    },
+    {
+      "label": ".reject",
+      "kind": 2,
+      "detail": "Filter elements (remove truthy)",
+      "documentation": { "value": "Returns a new array/hash excluding elements for which the block returns truthy.\n\n```ruby\n[1, 2, 3, 4].reject { |n| n.even? }  # => [1, 3]\n```" },
+      "insertText": ".reject { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_reject"
+    },
+    {
+      "label": ".reduce",
+      "kind": 2,
+      "detail": "Accumulate values",
+      "documentation": { "value": "Combines elements by applying a binary operation, accumulating a result.\n\n```ruby\n[1, 2, 3].reduce(0) { |sum, n| sum + n }  # => 6\n[1, 2, 3].reduce(:+)                       # => 6\n```" },
+      "insertText": ".reduce(${1:initial}) { |${2:acc}, ${3:el}| ${4:acc} }",
+      "insertTextRules": 4,
+      "sortText": "04_reduce"
+    },
+    {
+      "label": ".inject",
+      "kind": 2,
+      "detail": "Accumulate values (alias for reduce)",
+      "documentation": { "value": "Alias for `.reduce`. Combines elements by applying a binary operation.\n\n```ruby\n[1, 2, 3].inject(:+)  # => 6\n```" },
+      "insertText": ".inject(${1:initial}) { |${2:acc}, ${3:el}| ${4:acc} }",
+      "insertTextRules": 4,
+      "sortText": "04_inject"
+    },
+    {
+      "label": ".find",
+      "kind": 2,
+      "detail": "Find first matching element",
+      "documentation": { "value": "Returns the first element for which the block returns truthy, or `nil` if none.\n\n```ruby\n[1, 2, 3].find { |n| n.even? }  # => 2\n```" },
+      "insertText": ".find { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_find"
+    },
+    {
+      "label": ".detect",
+      "kind": 2,
+      "detail": "Find first matching (alias for find)",
+      "documentation": { "value": "Alias for `.find`. Returns the first element for which the block returns truthy.\n\n```ruby\n[1, 2, 3].detect { |n| n > 1 }  # => 2\n```" },
+      "insertText": ".detect { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_detect"
+    },
+    {
+      "label": ".any?",
+      "kind": 2,
+      "detail": "Check if any element matches",
+      "documentation": { "value": "Returns `true` if the block returns truthy for any element.\n\n```ruby\n[1, 2, 3].any? { |n| n > 2 }  # => true\n[1, 2, 3].any?(Integer)        # => true\n```" },
+      "insertText": ".any? { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_any"
+    },
+    {
+      "label": ".all?",
+      "kind": 2,
+      "detail": "Check if all elements match",
+      "documentation": { "value": "Returns `true` if the block returns truthy for every element.\n\n```ruby\n[2, 4, 6].all? { |n| n.even? }  # => true\n[2, 4, 6].all?(&:even?)         # => true\n```" },
+      "insertText": ".all? { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_all"
+    },
+    {
+      "label": ".none?",
+      "kind": 2,
+      "detail": "Check if no elements match",
+      "documentation": { "value": "Returns `true` if the block returns falsy for every element.\n\n```ruby\n[1, 3, 5].none? { |n| n.even? }  # => true\n```" },
+      "insertText": ".none? { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "04_none"
+    },
+    {
+      "label": ".count",
+      "kind": 2,
+      "detail": "Count elements",
+      "documentation": { "value": "Returns the number of elements. With an argument, counts matching elements. With a block, counts elements for which the block returns truthy.\n\n```ruby\n[1, 2, 3].count       # => 3\n[1, 2, 2].count(2)    # => 2\n[1, 2, 3].count(&:odd?) # => 2\n```" },
+      "insertText": ".count",
+      "sortText": "04_count"
+    },
+    {
+      "label": ".min",
+      "kind": 2,
+      "detail": "Find minimum element",
+      "documentation": { "value": "Returns the minimum element using `<=>` or a block.\n\n```ruby\n[3, 1, 2].min  # => 1\n```" },
+      "insertText": ".min",
+      "sortText": "04_min"
+    },
+    {
+      "label": ".max",
+      "kind": 2,
+      "detail": "Find maximum element",
+      "documentation": { "value": "Returns the maximum element using `<=>` or a block.\n\n```ruby\n[3, 1, 2].max  # => 3\n```" },
+      "insertText": ".max",
+      "sortText": "04_max"
+    },
+    {
+      "label": ".min_by",
+      "kind": 2,
+      "detail": "Find minimum by block",
+      "documentation": { "value": "Returns the element for which the block returns the minimum value.\n\n```ruby\nwords.min_by { |w| w.length }\nusers.min_by(&:age)\n```" },
+      "insertText": ".min_by { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_min_by"
+    },
+    {
+      "label": ".max_by",
+      "kind": 2,
+      "detail": "Find maximum by block",
+      "documentation": { "value": "Returns the element for which the block returns the maximum value.\n\n```ruby\nwords.max_by { |w| w.length }\nusers.max_by(&:age)\n```" },
+      "insertText": ".max_by { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_max_by"
+    },
+    {
+      "label": ".sum",
+      "kind": 2,
+      "detail": "Sum all elements",
+      "documentation": { "value": "Returns the sum of elements. Optionally takes an initial value and a block.\n\n```ruby\n[1, 2, 3].sum            # => 6\n[1, 2, 3].sum { |n| n * 2 } # => 12\n```" },
+      "insertText": ".sum",
+      "sortText": "04_sum"
+    },
+    {
+      "label": ".zip",
+      "kind": 2,
+      "detail": "Combine arrays element-wise",
+      "documentation": { "value": "Merges elements of self with corresponding elements from each argument array.\n\n```ruby\n[1, 2, 3].zip([4, 5, 6])  # => [[1, 4], [2, 5], [3, 6]]\n```" },
+      "insertText": ".zip(${1:other_array})",
+      "insertTextRules": 4,
+      "sortText": "04_zip"
+    },
+    {
+      "label": ".flat_map",
+      "kind": 2,
+      "detail": "Map and flatten",
+      "documentation": { "value": "Returns a new array with the concatenated results of running the block for every element.\n\n```ruby\n[[1, 2], [3, 4]].flat_map { |a| a }  # => [1, 2, 3, 4]\nusers.flat_map(&:roles)\n```" },
+      "insertText": ".flat_map { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_flat_map"
+    },
+    {
+      "label": ".each_with_index",
+      "kind": 2,
+      "detail": "Iterate with index",
+      "documentation": { "value": "Calls the block with each element and its index.\n\n```ruby\n['a', 'b', 'c'].each_with_index do |el, i|\n  puts \"#{i}: #{el}\"\nend\n```" },
+      "insertText": ".each_with_index { |${1:el}, ${2:i}| ${3} }",
+      "insertTextRules": 4,
+      "sortText": "04_each_with_index"
+    },
+    {
+      "label": ".each_with_object",
+      "kind": 2,
+      "detail": "Iterate with accumulator object",
+      "documentation": { "value": "Iterates with an arbitrary object, returning that object. Useful for building hashes or arrays.\n\n```ruby\n[1, 2, 3].each_with_object([]) { |n, arr| arr << n * 2 }\n# => [2, 4, 6]\n```" },
+      "insertText": ".each_with_object(${1:object}) { |${2:el}, ${3:obj}| ${4} }",
+      "insertTextRules": 4,
+      "sortText": "04_each_with_object"
+    },
+    {
+      "label": ".group_by",
+      "kind": 2,
+      "detail": "Group elements by block result",
+      "documentation": { "value": "Groups elements into a hash by the return value of the block.\n\n```ruby\n[1, 2, 3, 4].group_by(&:even?)\n# => { false: [1, 3], true: [2, 4] }\n```" },
+      "insertText": ".group_by { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_group_by"
+    },
+    {
+      "label": ".chunk",
+      "kind": 2,
+      "detail": "Chunk consecutive elements",
+      "documentation": { "value": "Enumerates over items, chunking them together based on the return value of the block.\n\n```ruby\n[1, 1, 2, 2, 3].chunk { |n| n }.to_a\n# => [[1, [1, 1]], [2, [2, 2]], [3, [3]]]\n```" },
+      "insertText": ".chunk { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "04_chunk"
+    },
+    {
+      "label": ".tally",
+      "kind": 2,
+      "detail": "Count occurrences",
+      "documentation": { "value": "Counts the occurrences of each element and returns a hash.\n\n```ruby\n['a', 'b', 'a', 'c', 'b', 'a'].tally\n# => { \"a\" => 3, \"b\" => 2, \"c\" => 1 }\n```" },
+      "insertText": ".tally",
+      "sortText": "04_tally"
+    },
+    {
+      "label": ".intersection",
+      "kind": 2,
+      "detail": "Array intersection",
+      "documentation": { "value": "Returns a new array containing elements common to all arrays.\n\n```ruby\n[1, 2, 3].intersection([2, 3, 4])  # => [2, 3]\n```" },
+      "insertText": ".intersection(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "04_intersection"
+    },
+    {
+      "label": ".union",
+      "kind": 2,
+      "detail": "Array union",
+      "documentation": { "value": "Returns a new array with elements from both arrays, removing duplicates.\n\n```ruby\n[1, 2, 3].union([3, 4, 5])  # => [1, 2, 3, 4, 5]\n```" },
+      "insertText": ".union(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "04_union"
+    },
+    {
+      "label": ".difference",
+      "kind": 2,
+      "detail": "Array difference",
+      "documentation": { "value": "Returns a new array containing elements not found in the other array(s).\n\n```ruby\n[1, 2, 3, 4].difference([2, 4])  # => [1, 3]\n```" },
+      "insertText": ".difference(${1:other})",
+      "insertTextRules": 4,
+      "sortText": "04_difference"
+    },
+    {
+      "label": ".sample",
+      "kind": 2,
+      "detail": "Random element(s)",
+      "documentation": { "value": "Returns a random element, or `n` random elements.\n\n```ruby\n[1, 2, 3].sample     # => 2 (random)\n[1, 2, 3].sample(2)  # => [3, 1] (random)\n```" },
+      "insertText": ".sample",
+      "sortText": "04_sample"
+    },
+    {
+      "label": ".shuffle",
+      "kind": 2,
+      "detail": "Randomly reorder elements",
+      "documentation": { "value": "Returns a new array with elements in random order.\n\n```ruby\n[1, 2, 3, 4, 5].shuffle  # => [3, 5, 1, 4, 2]\n```" },
+      "insertText": ".shuffle",
+      "sortText": "04_shuffle"
+    },
+    {
+      "label": ".rotate",
+      "kind": 2,
+      "detail": "Rotate array elements",
+      "documentation": { "value": "Returns a new array rotated by the given count.\n\n```ruby\n[1, 2, 3, 4].rotate     # => [2, 3, 4, 1]\n[1, 2, 3, 4].rotate(2)  # => [3, 4, 1, 2]\n```" },
+      "insertText": ".rotate(${1:count})",
+      "insertTextRules": 4,
+      "sortText": "04_rotate"
+    },
+    {
+      "label": ".combination",
+      "kind": 2,
+      "detail": "Generate combinations",
+      "documentation": { "value": "Yields all combinations of length `n` from the array.\n\n```ruby\n[1, 2, 3].combination(2).to_a\n# => [[1, 2], [1, 3], [2, 3]]\n```" },
+      "insertText": ".combination(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "04_combination"
+    },
+    {
+      "label": ".permutation",
+      "kind": 2,
+      "detail": "Generate permutations",
+      "documentation": { "value": "Yields all permutations of length `n` from the array.\n\n```ruby\n[1, 2, 3].permutation(2).to_a\n# => [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]\n```" },
+      "insertText": ".permutation(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "04_permutation"
+    },
+    {
+      "label": ".take",
+      "kind": 2,
+      "detail": "Take first n elements",
+      "documentation": { "value": "Returns the first `n` elements of the array.\n\n```ruby\n[1, 2, 3, 4, 5].take(3)  # => [1, 2, 3]\n```" },
+      "insertText": ".take(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "04_take"
+    },
+    {
+      "label": ".drop",
+      "kind": 2,
+      "detail": "Drop first n elements",
+      "documentation": { "value": "Returns the array after dropping the first `n` elements.\n\n```ruby\n[1, 2, 3, 4, 5].drop(2)  # => [3, 4, 5]\n```" },
+      "insertText": ".drop(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "04_drop"
+    },
+    {
+      "label": ".slice",
+      "kind": 2,
+      "detail": "Extract sub-array",
+      "documentation": { "value": "Returns a sub-array starting at the given index for the given length.\n\n```ruby\n[1, 2, 3, 4, 5].slice(1, 3)  # => [2, 3, 4]\n```" },
+      "insertText": ".slice(${1:start}, ${2:length})",
+      "insertTextRules": 4,
+      "sortText": "04_slice"
+    },
+    {
+      "label": ".dig",
+      "kind": 2,
+      "detail": "Safely access nested values",
+      "documentation": { "value": "Extracts the nested value specified by the sequence of indices/keys. Returns `nil` if any intermediate step is `nil`.\n\n```ruby\ndata = { a: { b: [1, 2, 3] } }\ndata.dig(:a, :b, 1)  # => 2\n```" },
+      "insertText": ".dig(${1:keys})",
+      "insertTextRules": 4,
+      "sortText": "04_dig"
+    },
+    {
+      "label": ".join",
+      "kind": 2,
+      "detail": "Join array elements into string",
+      "documentation": { "value": "Converts each element to a string and joins them with the given separator.\n\n```ruby\n['a', 'b', 'c'].join(', ')  # => \"a, b, c\"\n[1, 2, 3].join('-')          # => \"1-2-3\"\n```" },
+      "insertText": ".join('${1:separator}')",
+      "insertTextRules": 4,
+      "sortText": "04_join"
+    },
+    {
+      "label": ".keys",
+      "kind": 2,
+      "detail": "Get hash keys",
+      "documentation": { "value": "Returns an array of all keys in the hash.\n\n```ruby\n{ a: 1, b: 2 }.keys  # => [:a, :b]\n```" },
+      "insertText": ".keys",
+      "sortText": "05_keys"
+    },
+    {
+      "label": ".values",
+      "kind": 2,
+      "detail": "Get hash values",
+      "documentation": { "value": "Returns an array of all values in the hash.\n\n```ruby\n{ a: 1, b: 2 }.values  # => [1, 2]\n```" },
+      "insertText": ".values",
+      "sortText": "05_values"
+    },
+    {
+      "label": ".merge",
+      "kind": 2,
+      "detail": "Merge hashes",
+      "documentation": { "value": "Returns a new hash containing the contents of self and the other hash. Duplicate keys use values from the other hash.\n\n```ruby\n{ a: 1 }.merge({ b: 2 })          # => { a: 1, b: 2 }\n{ a: 1 }.merge({ a: 2 })           # => { a: 2 }\n{ a: 1 }.merge({ a: 2 }) { |k, v1, v2| v1 + v2 }  # => { a: 3 }\n```" },
+      "insertText": ".merge(${1:other_hash})",
+      "insertTextRules": 4,
+      "sortText": "05_merge"
+    },
+    {
+      "label": ".merge!",
+      "kind": 2,
+      "detail": "Merge hashes in place",
+      "documentation": { "value": "Merges the other hash into self, modifying self in place.\n\n```ruby\nh = { a: 1 }\nh.merge!({ b: 2 })  # h is now { a: 1, b: 2 }\n```" },
+      "insertText": ".merge!(${1:other_hash})",
+      "insertTextRules": 4,
+      "sortText": "05_merge_bang"
+    },
+    {
+      "label": ".fetch",
+      "kind": 2,
+      "detail": "Fetch hash value with default",
+      "documentation": { "value": "Returns the value for the given key. Raises `KeyError` if key is missing and no default is given.\n\n```ruby\nh = { a: 1 }\nh.fetch(:a)            # => 1\nh.fetch(:b, 'default') # => \"default\"\nh.fetch(:b) { |k| \"no #{k}\" }  # => \"no b\"\n```" },
+      "insertText": ".fetch(${1:key}, ${2:default})",
+      "insertTextRules": 4,
+      "sortText": "05_fetch"
+    },
+    {
+      "label": ".has_key?",
+      "kind": 2,
+      "detail": "Check if hash has key",
+      "documentation": { "value": "Returns `true` if the hash contains the given key.\n\n```ruby\n{ a: 1 }.has_key?(:a)  # => true\n```" },
+      "insertText": ".has_key?(${1:key})",
+      "insertTextRules": 4,
+      "sortText": "05_has_key"
+    },
+    {
+      "label": ".has_value?",
+      "kind": 2,
+      "detail": "Check if hash has value",
+      "documentation": { "value": "Returns `true` if the hash contains the given value.\n\n```ruby\n{ a: 1 }.has_value?(1)  # => true\n```" },
+      "insertText": ".has_value?(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "05_has_value"
+    },
+    {
+      "label": ".key?",
+      "kind": 2,
+      "detail": "Check key existence (alias)",
+      "documentation": { "value": "Returns `true` if the hash contains the given key. Alias for `has_key?`.\n\n```ruby\n{ a: 1 }.key?(:a)  # => true\n```" },
+      "insertText": ".key?(${1:key})",
+      "insertTextRules": 4,
+      "sortText": "05_key"
+    },
+    {
+      "label": ".value?",
+      "kind": 2,
+      "detail": "Check value existence (alias)",
+      "documentation": { "value": "Returns `true` if the hash contains the given value. Alias for `has_value?`.\n\n```ruby\n{ a: 1 }.value?(1)  # => true\n```" },
+      "insertText": ".value?(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "05_value"
+    },
+    {
+      "label": ".delete",
+      "kind": 2,
+      "detail": "Delete key from hash",
+      "documentation": { "value": "Removes the key-value pair and returns the value. Returns `nil` if key not found.\n\n```ruby\nh = { a: 1, b: 2 }\nh.delete(:a)  # => 1, h is { b: 2 }\n```" },
+      "insertText": ".delete(${1:key})",
+      "insertTextRules": 4,
+      "sortText": "05_delete"
+    },
+    {
+      "label": ".delete_if",
+      "kind": 2,
+      "detail": "Delete elements by condition",
+      "documentation": { "value": "Deletes every key-value pair for which the block returns truthy.\n\n```ruby\n{ a: 1, b: 2, c: 3 }.delete_if { |k, v| v > 1 }\n# => { a: 1 }\n```" },
+      "insertText": ".delete_if { |${1:k}, ${2:v}| ${3:condition} }",
+      "insertTextRules": 4,
+      "sortText": "05_delete_if"
+    },
+    {
+      "label": ".transform_keys",
+      "kind": 2,
+      "detail": "Transform hash keys",
+      "documentation": { "value": "Returns a new hash with keys transformed by the block.\n\n```ruby\n{ a: 1, b: 2 }.transform_keys(&:to_s)\n# => { \"a\" => 1, \"b\" => 2 }\n```" },
+      "insertText": ".transform_keys { |${1:k}| ${2:k} }",
+      "insertTextRules": 4,
+      "sortText": "05_transform_keys"
+    },
+    {
+      "label": ".transform_values",
+      "kind": 2,
+      "detail": "Transform hash values",
+      "documentation": { "value": "Returns a new hash with values transformed by the block.\n\n```ruby\n{ a: 1, b: 2 }.transform_values { |v| v * 2 }\n# => { a: 2, b: 4 }\n```" },
+      "insertText": ".transform_values { |${1:v}| ${2:v} }",
+      "insertTextRules": 4,
+      "sortText": "05_transform_values"
+    },
+    {
+      "label": ".to_a",
+      "kind": 2,
+      "detail": "Convert to array",
+      "documentation": { "value": "Converts the object to an array.\n\n```ruby\n{ a: 1, b: 2 }.to_a  # => [[:a, 1], [:b, 2]]\n(1..5).to_a           # => [1, 2, 3, 4, 5]\n```" },
+      "insertText": ".to_a",
+      "sortText": "05_to_a"
+    },
+    {
+      "label": ".invert",
+      "kind": 2,
+      "detail": "Swap hash keys and values",
+      "documentation": { "value": "Returns a new hash with keys and values swapped.\n\n```ruby\n{ a: 1, b: 2 }.invert  # => { 1 => :a, 2 => :b }\n```" },
+      "insertText": ".invert",
+      "sortText": "05_invert"
+    },
+    {
+      "label": ".except",
+      "kind": 2,
+      "detail": "Hash without specified keys",
+      "documentation": { "value": "Returns a new hash excluding the specified keys. Available in Ruby 3.0+.\n\n```ruby\n{ a: 1, b: 2, c: 3 }.except(:b)  # => { a: 1, c: 3 }\n```" },
+      "insertText": ".except(${1:keys})",
+      "insertTextRules": 4,
+      "sortText": "05_except"
+    },
+    {
+      "label": ".take_while",
+      "kind": 2,
+      "detail": "Take while condition is true",
+      "documentation": { "value": "Returns elements from the beginning while the block returns truthy.\n\n```ruby\n[1, 2, 3, 4, 5].take_while { |n| n < 4 }  # => [1, 2, 3]\n```" },
+      "insertText": ".take_while { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "06_take_while"
+    },
+    {
+      "label": ".drop_while",
+      "kind": 2,
+      "detail": "Drop while condition is true",
+      "documentation": { "value": "Drops elements from the beginning while the block returns truthy, then returns the rest.\n\n```ruby\n[1, 2, 3, 4, 5].drop_while { |n| n < 3 }  # => [3, 4, 5]\n```" },
+      "insertText": ".drop_while { |${1:el}| ${2:condition} }",
+      "insertTextRules": 4,
+      "sortText": "06_drop_while"
+    },
+    {
+      "label": ".lazy",
+      "kind": 2,
+      "detail": "Create lazy enumerator",
+      "documentation": { "value": "Returns a lazy enumerator. Operations are deferred until values are needed.\n\n```ruby\n(1..Float::INFINITY).lazy.select(&:odd?).take(5).to_a\n# => [1, 3, 5, 7, 9]\n```" },
+      "insertText": ".lazy",
+      "sortText": "06_lazy"
+    },
+    {
+      "label": ".filter_map",
+      "kind": 2,
+      "detail": "Filter and map in one step",
+      "documentation": { "value": "Returns an array containing truthy results of running the block for every element.\n\n```ruby\n[1, 2, 3, 4, 5].filter_map { |n| n * 2 if n.odd? }\n# => [2, 6, 10]\n```" },
+      "insertText": ".filter_map { |${1:el}| ${2:el} }",
+      "insertTextRules": 4,
+      "sortText": "06_filter_map"
+    },
+    {
+      "label": "File.read",
+      "kind": 1,
+      "detail": "Read entire file contents",
+      "documentation": { "value": "Opens the file, reads the entire contents, and closes it. Returns a string.\n\n```ruby\ncontent = File.read('config.yml')\n```" },
+      "insertText": "File.read('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_read"
+    },
+    {
+      "label": "File.write",
+      "kind": 1,
+      "detail": "Write string to file",
+      "documentation": { "value": "Opens the file, writes the string, and closes it. Creates the file if it doesn't exist.\n\n```ruby\nFile.write('output.txt', content)\n```" },
+      "insertText": "File.write('${1:path}', ${2:data})",
+      "insertTextRules": 4,
+      "sortText": "07_file_write"
+    },
+    {
+      "label": "File.open",
+      "kind": 1,
+      "detail": "Open a file",
+      "documentation": { "value": "Opens a file with the given mode. When given a block, closes the file automatically.\n\n```ruby\nFile.open('data.txt', 'r') do |f|\n  f.each_line { |line| puts line }\nend\n```" },
+      "insertText": "File.open('${1:path}', '${2:r}') do |${3:f}|\n  ${4:# body}\nend",
+      "insertTextRules": 4,
+      "sortText": "07_file_open"
+    },
+    {
+      "label": "File.exist?",
+      "kind": 1,
+      "detail": "Check if file exists",
+      "documentation": { "value": "Returns `true` if the named file exists.\n\n```ruby\nFile.exist?('config.yml')  # => true or false\n```" },
+      "insertText": "File.exist?('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_exist"
+    },
+    {
+      "label": "File.delete",
+      "kind": 1,
+      "detail": "Delete a file",
+      "documentation": { "value": "Deletes the named file(s). Raises `Errno::ENOENT` if the file does not exist.\n\n```ruby\nFile.delete('temp.txt')\n```" },
+      "insertText": "File.delete('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_delete"
+    },
+    {
+      "label": "File.rename",
+      "kind": 1,
+      "detail": "Rename a file",
+      "documentation": { "value": "Renames the file.\n\n```ruby\nFile.rename('old.txt', 'new.txt')\n```" },
+      "insertText": "File.rename('${1:old_name}', '${2:new_name}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_rename"
+    },
+    {
+      "label": "File.join",
+      "kind": 1,
+      "detail": "Join path components",
+      "documentation": { "value": "Joins path components with the platform file separator.\n\n```ruby\nFile.join('usr', 'local', 'bin')  # => \"usr/local/bin\"\n```" },
+      "insertText": "File.join(${1:paths})",
+      "insertTextRules": 4,
+      "sortText": "07_file_join"
+    },
+    {
+      "label": "File.dirname",
+      "kind": 1,
+      "detail": "Get directory part of path",
+      "documentation": { "value": "Returns the directory portion of the path.\n\n```ruby\nFile.dirname('/usr/local/bin/ruby')  # => \"/usr/local/bin\"\n```" },
+      "insertText": "File.dirname('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_dirname"
+    },
+    {
+      "label": "File.basename",
+      "kind": 1,
+      "detail": "Get filename from path",
+      "documentation": { "value": "Returns the last component of the filename.\n\n```ruby\nFile.basename('/usr/local/bin/ruby')       # => \"ruby\"\nFile.basename('/usr/local/bin/ruby.rb', '.rb') # => \"ruby\"\n```" },
+      "insertText": "File.basename('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_basename"
+    },
+    {
+      "label": "File.extname",
+      "kind": 1,
+      "detail": "Get file extension",
+      "documentation": { "value": "Returns the file extension including the dot.\n\n```ruby\nFile.extname('test.rb')   # => \".rb\"\nFile.extname('Makefile')  # => \"\"\n```" },
+      "insertText": "File.extname('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_file_extname"
+    },
+    {
+      "label": "Dir.glob",
+      "kind": 1,
+      "detail": "Find files by pattern",
+      "documentation": { "value": "Returns filenames matching the given glob pattern.\n\n```ruby\nDir.glob('*.rb')          # all .rb files\nDir.glob('**/*.rb')       # recursive\nDir.glob('lib/**/*.rb')\n```" },
+      "insertText": "Dir.glob('${1:pattern}')",
+      "insertTextRules": 4,
+      "sortText": "07_dir_glob"
+    },
+    {
+      "label": "Dir.entries",
+      "kind": 1,
+      "detail": "List directory entries",
+      "documentation": { "value": "Returns an array of filenames in the given directory, including `.` and `..`.\n\n```ruby\nDir.entries('.')  # => [\".\", \"..\", \"file1.rb\", ...]\n```" },
+      "insertText": "Dir.entries('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_dir_entries"
+    },
+    {
+      "label": "IO.read",
+      "kind": 1,
+      "detail": "Read from IO",
+      "documentation": { "value": "Opens the file and reads the entire content as a string.\n\n```ruby\ncontent = IO.read('file.txt')\n```" },
+      "insertText": "IO.read('${1:path}')",
+      "insertTextRules": 4,
+      "sortText": "07_io_read"
+    },
+    {
+      "label": "Integer()",
+      "kind": 1,
+      "detail": "Strict integer conversion",
+      "documentation": { "value": "Converts the argument to an Integer. Raises `ArgumentError` on invalid input (unlike `to_i`).\n\n```ruby\nInteger('42')     # => 42\nInteger('0xff', 16)  # => 255\n```" },
+      "insertText": "Integer(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_integer"
+    },
+    {
+      "label": "Float()",
+      "kind": 1,
+      "detail": "Strict float conversion",
+      "documentation": { "value": "Converts the argument to a Float. Raises `ArgumentError` on invalid input.\n\n```ruby\nFloat('3.14')  # => 3.14\n```" },
+      "insertText": "Float(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_float"
+    },
+    {
+      "label": "String()",
+      "kind": 1,
+      "detail": "Convert to string",
+      "documentation": { "value": "Converts the argument to a String by calling `to_s`.\n\n```ruby\nString(42)     # => \"42\"\nString(nil)    # => \"\"\n```" },
+      "insertText": "String(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_string"
+    },
+    {
+      "label": "Array()",
+      "kind": 1,
+      "detail": "Convert to array",
+      "documentation": { "value": "Converts the argument to an Array. Calls `to_ary` then `to_a`. Returns `[]` for `nil`.\n\n```ruby\nArray(nil)     # => []\nArray([1, 2])  # => [1, 2]\nArray(1)       # => [1]\n```" },
+      "insertText": "Array(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_array"
+    },
+    {
+      "label": "Hash()",
+      "kind": 1,
+      "detail": "Convert to hash",
+      "documentation": { "value": "Converts the argument to a Hash.\n\n```ruby\nHash(nil)          # => {}\nHash(a: 1, b: 2)   # => { a: 1, b: 2 }\n```" },
+      "insertText": "Hash(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "08_hash"
+    },
+    {
+      "label": "loop",
+      "kind": 1,
+      "detail": "Infinite loop",
+      "documentation": { "value": "Repeatedly executes the block. Break out with `break`.\n\n```ruby\nloop do\n  input = gets.chomp\n  break if input == 'quit'\n  puts input\nend\n```" },
+      "insertText": "loop do\n  ${1:# body}\n  break if ${2:condition}\nend",
+      "insertTextRules": 4,
+      "sortText": "08_loop"
+    },
+    {
+      "label": "sleep",
+      "kind": 1,
+      "detail": "Pause execution",
+      "documentation": { "value": "Suspends the current thread for the given number of seconds.\n\n```ruby\nsleep 1      # sleep 1 second\nsleep 0.5    # sleep 500ms\n```" },
+      "insertText": "sleep ${1:seconds}",
+      "insertTextRules": 4,
+      "sortText": "08_sleep"
+    },
+    {
+      "label": "rand",
+      "kind": 1,
+      "detail": "Generate random number",
+      "documentation": { "value": "Returns a random number. Without argument, returns a float between 0.0 and 1.0. With an integer, returns 0..n-1.\n\n```ruby\nrand        # => 0.5312...\nrand(10)    # => 0..9\nrand(1..6)  # => 1..6\n```" },
+      "insertText": "rand(${1:max})",
+      "insertTextRules": 4,
+      "sortText": "08_rand"
+    },
+    {
+      "label": "exit",
+      "kind": 1,
+      "detail": "Exit the program",
+      "documentation": { "value": "Terminates the program with an optional exit status code.\n\n```ruby\nexit       # exits with status 0\nexit(1)    # exits with status 1\n```" },
+      "insertText": "exit(${1:0})",
+      "insertTextRules": 4,
+      "sortText": "08_exit"
+    },
+    {
+      "label": "abort",
+      "kind": 1,
+      "detail": "Abort with message",
+      "documentation": { "value": "Terminates the program with an error message written to STDERR and exit status 1.\n\n```ruby\nabort 'Fatal error occurred'\n```" },
+      "insertText": "abort '${1:message}'",
+      "insertTextRules": 4,
+      "sortText": "08_abort"
+    },
+    {
+      "label": "system",
+      "kind": 1,
+      "detail": "Execute shell command",
+      "documentation": { "value": "Executes the given command in a subshell. Returns `true` on success, `false` on failure, `nil` if command not found.\n\n```ruby\nsystem('ls -la')\nsystem('echo', 'hello')\n```" },
+      "insertText": "system('${1:command}')",
+      "insertTextRules": 4,
+      "sortText": "08_system"
+    },
+    {
+      "label": "exec",
+      "kind": 1,
+      "detail": "Replace process with command",
+      "documentation": { "value": "Replaces the current process with the given external command. Never returns on success.\n\n```ruby\nexec('ls', '-la')\n```" },
+      "insertText": "exec('${1:command}')",
+      "insertTextRules": 4,
+      "sortText": "08_exec"
+    },
+    {
+      "label": "gets",
+      "kind": 1,
+      "detail": "Read line from stdin",
+      "documentation": { "value": "Reads a line from STDIN. Returns `nil` at end of input.\n\n```ruby\ninput = gets\ninput = gets.chomp  # remove trailing newline\n```" },
+      "insertText": "gets",
+      "sortText": "08_gets"
+    },
+    {
+      "label": "chomp",
+      "kind": 1,
+      "detail": "Remove trailing newline from input",
+      "documentation": { "value": "Commonly chained with `gets` to remove the trailing newline from user input.\n\n```ruby\nname = gets.chomp\n```" },
+      "insertText": "gets.chomp",
+      "sortText": "08_chomp"
+    }
+  ]
+}