Nvim :help pages, generated from source using the tree-sitter-vimdoc parser.

The Ruby Interface to Vim ruby Ruby
The home page for ruby is https://www.ruby-lang.org/. You can find links for downloading Ruby there.

1. Commands ruby-commands

:ruby :rub :rub[y] {cmd} Execute Ruby command {cmd}. A command to try it out:
:ruby print "Hello"
:rub[y] << [trim] [{endmarker}] {script} {endmarker} Execute Ruby script {script}.
If [endmarker] is omitted, it defaults to a dot '.' like for the :append and :insert commands. Refer to :let-heredoc for more information.
This form of the :ruby command is mainly useful for including ruby code in vim scripts.
Example Vim script:
function! RedGem()
ruby << EOF
class Garnet
        def initialize(s)
                @buffer = VIM::Buffer.current
        def vimputs(s)
gem = Garnet.new("pretty")
To see what version of Ruby you have:
:ruby print RUBY_VERSION
:rubydo :rubyd E265 :[range]rubyd[o] {cmd} Evaluate Ruby command {cmd} for each line in the [range], with $_ being set to the text of each line in turn, without a trailing <EOL>. Setting $_ will change the text, but note that it is not possible to add or delete lines using this command. The default for [range] is the whole file: "1,$".
:rubyfile :rubyf :rubyf[ile] {file} Execute the Ruby script in {file}. This is the same as :ruby load 'file', but allows file name completion.
Executing Ruby commands is not possible in the sandbox.

2. The VIM module ruby-vim

Ruby code gets all of its access to vim via the "VIM" module.
print "Hello"                              # displays a message
VIM.command(cmd)                      # execute an Ex command
num = VIM::Window.count                      # gets the number of windows
w = VIM::Window[n]                      # gets window "n"
cw = VIM::Window.current              # gets the current window
num = VIM::Buffer.count                      # gets the number of buffers
b = VIM::Buffer[n]                      # gets buffer "n"
cb = VIM::Buffer.current              # gets the current buffer
w.height = lines                      # sets the window height
w.cursor = [row, col]                      # sets the window cursor position
pos = w.cursor                              # gets an array [row, col]
name = b.name                              # gets the buffer file name
line = b[n]                              # gets a line from the buffer
num = b.count                              # gets the number of lines
b[n] = str                              # sets a line in the buffer
b.delete(n)                              # deletes a line
b.append(n, str)                      # appends a line after n
line = VIM::Buffer.current.line       # gets the current line
num = VIM::Buffer.current.line_number # gets the current line number
VIM::Buffer.current.line = "test"     # sets the current line number
Module Functions:
ruby-message VIM::message({msg}) Displays the message {msg}.
ruby-set_option VIM::set_option({arg}) Sets a vim option. {arg} can be any argument that the ":set" command accepts. Note that this means that no spaces are allowed in the argument! See :set.
ruby-command VIM::command({cmd}) Executes Ex command {cmd}.
ruby-evaluate VIM::evaluate({expr}) Evaluates {expr} using the vim internal expression evaluator (see expression). Returns the expression result as a string. A List is turned into a string by joining the items and inserting line breaks.

3. VIM::Buffer objects ruby-buffer

VIM::Buffer objects represent vim buffers.
Class Methods:
current Returns the current buffer object. count Returns the number of buffers. self[{n}] Returns the buffer object for the number {n}. The first number is 0.
name Returns the full name of the buffer. number Returns the number of the buffer. count Returns the number of lines. length Returns the number of lines. self[{n}] Returns a line from the buffer. {n} is the line number. self[{n}] = {str} Sets a line in the buffer. {n} is the line number. delete({n}) Deletes a line from the buffer. {n} is the line number. append({n}, {str}) Appends a line after the line {n}. line Returns the current line of the buffer if the buffer is active. line = {str} Sets the current line of the buffer if the buffer is active. line_number Returns the number of the current line if the buffer is active.

4. VIM::Window objects ruby-window

VIM::Window objects represent vim windows.
Class Methods:
current Returns the current window object. count Returns the number of windows. self[{n}] Returns the window object for the number {n}. The first number is 0.
buffer Returns the buffer displayed in the window. height Returns the height of the window. height = {n} Sets the window height to {n}. width Returns the width of the window. width = {n} Sets the window width to {n}. cursor Returns a [row, col] array for the cursor position. First line number is 1 and first column number is 0. cursor = [{row}, {col}] Sets the cursor position to {row} and {col}.

5. Global variables ruby-globals

There are two global variables.
$curwin The current window object. $curbuf The current buffer object.

6. rubyeval() Vim function ruby-rubyeval

To facilitate bi-directional interface, you can use rubyeval() function to evaluate Ruby expressions and pass their values to Vim script.
The Ruby value "true", "false" and "nil" are converted to v:true, v:false and v:null, respectively.
Commands index
Quick reference