[{"result":{"data":[{"id":"33ea8752-c402-4200-96a1-43ab6e14f5cf","title":"feat!: depracate `REPLSendMotion`, use `REPLSendOperator` instead.","text":"feat!: depracate `REPLSendMotion`, use `REPLSendOperator` instead.","type":"breaking-change","createdAt":"2023-11-10T02:16:21.162Z","breakingChange":{"id":84,"postId":"33ea8752-c402-4200-96a1-43ab6e14f5cf","pluginId":56793,"externalUrl":"https://github.com/milanglacier/yarepl.nvim/commit/9d248aed8e23fa5f45ca8233d4db654729eec43c","sha":"9d248aed8e23fa5f45ca8233d4db654729eec43c","plugin":{"id":56793,"owner":"milanglacier","name":"yarepl.nvim","type":"github","source":"awesome-neovim","category":"code-runner","link":"https://github.com/milanglacier/yarepl.nvim","shortDescription":"Yet Another REPL, flexible, supporting multiple paradigms to interact with REPLs, project-level configs, working with tmux, telescope integration, and native dot repeat.","createdAt":"2023-06-04T17:40:51.251Z","readme":"- [yarepl.nvim](#yareplnvim)\n- [What is yarepl.nvim?](#what-is-yareplnvim-)\n- [Why yarepl.nvim?](#why-yareplnvim-)\n- [Installation](#installation)\n- [Configuration](#configuration)\n * [Setup](#setup)\n * [Commands](#commands)\n + [REPLStart](#replstart)\n + [REPLAttachBufferToREPL](#replattachbuffertorepl)\n + [REPLDetachBufferToREPL](#repldetachbuffertorepl)\n + [REPLCleanup](#replcleanup)\n + [REPLFocus](#replfocus)\n + [REPLHide](#replhide)\n + [REPLHideOrFocus](#replhideorfocus)\n + [REPLClose](#replclose)\n + [REPLSwap](#replswap)\n + [REPLSendVisual](#replsendvisual)\n + [REPLSendLine](#replsendline)\n + [REPLSendOperator](#replsendoperator)\n + [REPLExec](#replexec)\n- [Window configuration](#window-configuration)\n- [Add your own REPLs](#add-your-own-repls)\n- [Example keybinding setup](#example-keybinding-setup)\n- [Telescope Integration](#telescope-integration)\n- [Set up project-level REPLs](#set-up-project-level-repls)\n- [Create persistent REPLs in tmux](#create-persistent-repls-in-tmux)\n- [FAQ](#faq)\n * [How do I avoid clutter from the bufferline plugin?](#how-do-i-avoid-clutter-from-the-bufferline-plugin-)\n * [REPLSendVisual is not functioning properly](#replsendvisual-is-not-functioning-properly)\n- [Limitations](#limitations)\n- [Acknowledgements](#acknowledgements)\n\n# yarepl.nvim\n\nYet Another REPL is a flexible REPL (Read-Eval-Print Loop) management tool that\nsupports multiple paradigms for interacting with REPLs. It offers project-level\nconfigurations, works with tmux, integrates with Telescope, and provides a\nnative dot repeat feature, without requiring vim-repeat.\n\n# What is yarepl.nvim?\n\nYarepl.nvim is a powerful and flexible REPL (Read-Eval-Print-Loop) management\nplugin for Neovim. It simplifies the process of interacting with a REPL and\ntext buffer, making tasks such as sending and managing text and REPL buffers\neffortless.\n\nFlexibility and parallelism are top priority. With yarepl.nvim, you can easily\ninteract with multiple REPLs using various paradigms, such as sending text from\nmultiple buffers to a single REPL, sending text from a single buffer to\nmultiple REPLs, and sending text to a specific type of REPL. Plus, it offers\nnative dot repeat functionality without requiring `vim-repeat`.\n\n# Why yarepl.nvim?\n\nAs a data scientist, talking with different REPLs is an essentail part of my\nworkflow. I almost spending lifes in communicating with various REPLs, like R,\nPython, and Bash.\n\nWith multiple projects at hand, I require the ability to send text from\ndifferent files to REPLs with the same type (such as multiple ipython REPLs).\n\nIn instances where I'm performing time-consuming tasks, but need to conduct\nfurther experimentation on the current file, I also require the capability to\nsend text from the same buffer to multiple REPLs.\n\nFurthermore, when conducting mixed-language programming in a literate\nprogramming style in text format such as `rmarkdown`, `quarto`, or plain\n`markdown`, I need to send text in the buffer to different REPLs such as R and\nPython .\n\nAs a CLI fnatic, to communicate with chatgpt, I prefer through a REPL `aichat`.\nAdditionally, I require a set of global hotkeys and an isolated REPL\nenvironment to facilitate communication with 'aichat' separately without any\ninterference with other REPLs.\n\nUnfortunately, currently available REPL plugins do not afford me such great\nflexibility in managing REPL in multiple ways. This is why 'yarepl.nvim' was\ncreated.\n\n# Installation\n\n`nvim 0.9` is required. Although `nvim 0.8` may also work, there are no plans\nto ensure backward compatibility with `nvim 0.8` if there are any compatibility\nissues.\n\npacker.nvim:\n\n```lua\nuse { 'milanglacier/yarepl.nvim' }\n```\n\nlazy.nvim:\n\n```lua\n{ 'milanglacier/yarepl.nvim', config = true }\n```\n\n`yarepl.nvim` does not require any dependencies but functions better with the following plugins:\n\n1. `telescope.nvim`. `yarepl.nvim` provides a telescope extension for REPL\n previewer.\n\n2. A UI frontend that provides an alternative frontend for `vim.ui.select`.\n Some options are `dressing.nvim` or `telescope-ui-select.nvim` (only one of\n them needs to be installed).\n\n# Configuration\n\n## Setup\n\n```lua\n-- below is the default configuration, there's no need to copy paste them if\n-- you are satisfied with the default configuration, just calling\n-- `require('yarepl').setup {}` is sufficient.\nlocal yarepl = require 'yarepl'\n\nyarepl.setup {\n -- see `:h buflisted`, whether the REPL buffer should be buflisted.\n buflisted = true,\n -- whether the REPL buffer should be a scratch buffer.\n scratch = true,\n -- the filetype of the REPL buffer created by `yarepl`\n ft = 'REPL',\n -- How yarepl open the REPL window, can be a string or a lua function.\n -- See below example for how to configure this option\n wincmd = 'belowright 15 split',\n -- The available REPL palattes that `yarepl` can create REPL based on\n metas = {\n aichat = { cmd = 'aichat', formatter = yarepl.formatter.bracketed_pasting },\n radian = { cmd = 'radian', formatter = yarepl.formatter.bracketed_pasting },\n ipython = { cmd = 'ipython', formatter = yarepl.formatter.bracketed_pasting },\n python = { cmd = 'python', formatter = yarepl.formatter.trim_empty_lines },\n R = { cmd = 'R', formatter = yarepl.formatter.trim_empty_lines },\n bash = { cmd = 'bash', formatter = yarepl.formatter.trim_empty_lines },\n zsh = { cmd = 'zsh', formatter = yarepl.formatter.bracketed_pasting },\n },\n -- when a REPL process exits, should the window associated with those REPLs closed?\n close_on_exit = true,\n -- whether automatically scroll to the bottom of the REPL window after sending\n -- text? This feature would be helpful if you want to ensure that your view\n -- stays updated with the latest REPL output.\n scroll_to_bottom_after_sending = true,\n os = {\n -- Some hacks for Windows. macOS and Linux users can simply ignore\n -- them. The default options are recommended for Windows user.\n windows = {\n -- Send a final `\\r` to the REPL with delay,\n send_delayed_cr_after_sending = true,\n },\n },\n}\n```\n\n## Commands\n\n`yarepl` doesn't provide any keybindings. Instead, it offers a variety of\ncommands that you can use to create your own keybindings. We'll also provide an\nexample configuration for keybindings based on these commands.\n\nHere is a list of available commands:\n\n### REPLStart\n\nCreates a REPL with id `i` from the list of available REPLs.\n\nYou can create a REPL with a specific id by providing a count, such as\n`3REPLStart` for a REPL with id `3`. If no count is provided, REPL 1 will be\ncreated. You can also provide a name as an argument. If no argument is given,\nyou'll be prompted to select a REPL from the list of available ones. If the id\nis already in use, it will focus on the REPL with that id. If you append a `!`\nto the command, the current buffer will attach to the newly created REPL, for\ninstance, `REPLStart!` or `3REPLStart!`. Note that attachment only happens when\na new REPL is created.\n\n### REPLAttachBufferToREPL\n\nAttaches the current buffer to REPL `i`, for instance,\n`3REPLAttachBufferToREPL` will attach the current buffer to REPL 3. If no count\nis provided, you'll be prompted to select the REPL you want to attach the\ncurrent buffer to. If you add a trailing `!`, it will attempt to detach the\ncurrent buffer from any REPL.\n\n### REPLDetachBufferToREPL\n\nDetach current buffer from any REPL.\n\n### REPLCleanup\n\nCleans up any invalid REPLs and rearranges the sequence of REPL ids. Usually,\nthere's no need to use this command manually since invalid REPLs are cleaned up\nautomatically at the appropriate time.\n\n### REPLFocus\n\nFocuses on REPL `i` or the REPL that the current buffer is attached to.\n\nYou can provide an optional argument, and the function will attempt to focus on\nthe closest REPL with the specified name. If no count is supplied, it will try\nto focus on the REPL that the current buffer is attached to. If the current\nbuffer isn't attached to any REPL, it will use REPL 1. If you add a count `i`,\nit will focus on the REPL `i`.\n\nHere are some examples of how to use this command:\n\n1. `REPLFocus` will try to focus on the REPL that the current buffer is\n attached to. If the current buffer isn't attached to any REPL, it will use\n REPL 1.\n\n2. `REPLFocus ipython` will try to focus on the closest REPL with the name\n `ipython` starting from id `1`.\n\n3. `3REPLFocus` will focus on REPL 3.\n\n4. `3REPLFocus ipython` will try to focus on the closest REPL with the name\n `ipython` starting from id `3`.\n\n### REPLHide\n\nHides REPL `i` or the REPL that the current buffer is attached to.\n\nIf you provide an optional argument, the function will attempt to hide the\nclosest REPL with the specified name. When no count is supplied, it will try to\nhide the REPL that the current buffer is attached to. If the current buffer\nisn't attached to any REPL, it will use REPL 1. If you add a count `i`, it will\nhide REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLHide` will try to hide the REPL that the current buffer is attached to.\n If the current buffer isn't attached to any REPL, it will use REPL 1.\n\n2. `REPLHide ipython` will try to hide the closest REPL with the name `ipython`\n starting from id `1`.\n\n3. `3REPLHide` will hide REPL 3.\n\n4. `3REPLHide ipython` will try to hide the closest REPL with the name\n `ipython` starting from id `3`.\n\n### REPLHideOrFocus\n\nHides or focuses on REPL `i` or the REPL that the current buffer is attached\nto.\n\nIf you provide an optional argument, the function will attempt to hide or focus\non the closest REPL with the specified name. When no count is supplied, it will\ntry to hide or focus on the REPL that the current buffer is attached to. If the\ncurrent buffer isn't attached to any REPL, it will use REPL 1. If you add a\ncount `i`, it will hide REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLHideOrFocus` will try to hide or focus on the REPL that the current\n buffer is attached to. If the current buffer isn't attached to any REPL, it\n will use REPL 1.\n\n2. `REPLHideOrFocus ipython` will try to hide or focus on the closest REPL with\n the name `ipython` starting from id `1`.\n\n3. `3REPLHideOrFocus` will hide or focus on REPL 3.\n\n4. `3REPLHideOrFocus ipython` will try to hide or focus on the closest REPL\n with the name `ipython` starting from id `3`.\n\n### REPLClose\n\nCloses REPL `i` or the REPL that the current buffer is attached to.\n\nIf you provide an optional argument, the function will attempt to close the\nclosest REPL with the specified name. If no count is supplied, it will try to\nclose the REPL that the current buffer is attached to. If the current buffer\nisn't attached to any REPL, it will use REPL 1. If you add a count `i`, it will\nclose REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLClose` will try to close the REPL that the current buffer is attached\n to. If the current buffer isn't attached to any REPL, it will use REPL 1.\n\n2. `REPLClose ipython` will try to close the closest REPL with the name\n `ipython` and starting from id `1`.\n\n3. `3REPLClose` will close REPL 3.\n\n4. `3REPLClose ipython` will try to close the closest REPL with the name\n `ipython` starting from id `3`.\n\n### REPLSwap\n\nSwaps two REPLs. If no REPL ID is provided, you'll be prompted to select both\nREPLs. If you provide one REPL ID, you'll be prompted to select the second\nREPL.\n\n### REPLSendVisual\n\nSends the visual range to REPL `i` or the REPL that the current buffer\nis attached to.\n\nIf you provide an optional argument, the function will attempt to send to the\nclosest REPL with the specified name. If no count is supplied, it will try to\nsend to the REPL that the current buffer is attached to. If the current buffer\nisn't attached to any REPL, it will use REPL 1. If you add a count `i`, it will\nsend to REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLSendVisual` sends the visual range to the REPL that the current buffer\n is attached to. If the buffer is not attached to any REPL, it uses REPL 1.\n\n2. `3REPLSendVisual` sends the visual range to REPL 3.\n\n3. `REPLSendVisual ipython` sends the visual range to the closest ipython REPL\n relative to id `1`.\n\n4. `3REPLSendVisual ipython` sends the visual range to the closest ipython REPL\n relative to id `3`.\n\nNote that due to a limitation of vim, when using `REPLSendVisual` via cmdline\nrather than in a keymap, you must press `Control+u` before using the command.\nFor example, `V3j:3REPLSendVisual` sends the selected three lines to\nREPL `3`. However, you do not need to specify `Control+u` in your keymap as the\nfunction will do this for you.\n\n### REPLSendLine\n\nSends current line to REPL `i` or the REPL that current buffer is attached to.\n\nIf you provide an optional argument, the function will attempt to send to the\nclosest REPL with the specified name. If no count is supplied, it will try to\nsend to the REPL that the current buffer is attached to. If the current buffer\nisn't attached to any REPL, it will use REPL 1. If you add a count `i`, it will\nsend to REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLSendLine` sends the current line to the REPL that the current buffer\n is attached to. If the buffer is not attached to any REPL, it uses REPL 1.\n\n2. `3REPLSendLine` sends the current line to REPL 3.\n\n3. `REPLSendLine ipython` sends the current line to the closest ipython REPL\n relative to id `1`.\n\n4. `3REPLSendLine ipython` sends the current line to the closest ipython REPL\n relative to id `3`.\n\n### REPLSendOperator\n\nThe opeerator to send the text to REPL `i` or the REPL that the current buffer\nis attached to.\n\nIf you provide an optional argument, the function will attempt to send to the\nclosest REPL with the specified name. If no count is supplied, it will try to\nsend to the REPL that the current buffer is attached to. If the current buffer\nisn't attached to any REPL, it will use REPL 1. If you add a count `i`, it will\nsend to REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLSendOperator` acts as the operator to send the text to the REPL that\n the current buffer is attached to. If the buffer is not attached to any\n REPL, it uses REPL 1.\n\n2. `3REPLSendOperator` sends the motion to REPL 3.\n\n3. `REPLSendOperator ipython` sends the motion to the closest ipython REPL\n relative to id `1`.\n\n4. `3REPLSendOperator ipython` sends the motion to the closest ipython REPL\n relative to id `3`.\n\n`REPLSendOperator` is **dot-repeatable**, you do not need to install\nvim-repeat to make it work.\n\n### REPLExec\n\nSends the command typed in the cmdline to REPL `i` or the REPL that the current\nbuffer is attached to.\n\nIf the first argument of this command is `$NAME`, the function will attempt to\nsend to the closest REPL with the specified `NAME`. If no count is supplied, it\nwill try to send to the REPL that the current buffer is attached to. If the\ncurrent buffer isn't attached to any REPL, it will use REPL 1. If you add a\ncount `i`, it will send to REPL `i`.\n\nHere are examples of how to use this command:\n\n1. `REPLExec %run a_file.py` will send the command `%run a_file.py` to the REPL 1.\n\n2. `3REPLExec print(\"hello world\")` will send the command `print(\"hello\n world\")` to the REPL 3.\n\n3. `REPLExec $ipython %whos` will send the command `%whos` to the closest\n ipython REPL relative to id 1.\n\n4. `REPLExec $ipython %whos` will send the command `%whos` to the closest\n ipython REPL relative to id 3.\n\n5. `REPLExec print(\"hello world\")^Mprint(\"hello world again\")` will send the\n following two lines to the REPL current buffer is attached to or REPL 1.\n\n```python\nprint(\"hello world\")\nprint(\"hello world again\")\n```\n\nNote:\n\n1. To type a **literal** `` (`^M`) in `cmdline`, you must press\n ` ` rather than directly type `Enter`.\n\n2. Some neovim command will interpolate `%` to the file name of current buffer.\n But `REPLExec` will not do this for you. The interpolation only happens for\n the first `$` to get the desired `REPL` name.\n\n# Window configuration\n\nif `wincmd` is a string, `yarepl` will execute it as a vimscript command.\n\n```lua\nwincmd = 'belowright 15 split'\n-- will create a horizontal split below the current using window and takes up 15 lines for the new window\nwincmd = 'vertical 30 split'\n-- will create a vertical split right to the current using window and takes up 30 columns for the new window\n```\n\nIn addition to passing a string to `wincmd`, you can also pass a Lua function.\nThis function accepts two parameters: the buffer number of the REPL buffer, and\nthe name of the REPL (the keys of `metas`).\n\n```lua\nwincmd = function(bufnr, name)\n if name == 'ipython' then\n vim.api.nvim_open_win(bufnr, true, {\n relative = 'editor',\n row = math.floor(vim.o.lines * 0.25),\n col = math.floor(vim.o.columns * 0.25),\n width = math.floor(vim.o.columns * 0.5),\n height = math.floor(vim.o.lines * 0.5),\n style = 'minimal',\n title = name,\n border = 'rounded',\n title_pos = 'center',\n })\n else\n vim.cmd [[belowright 15 split]]\n vim.api.nvim_set_current_buf(bufnr)\n end\nend\n```\n\nThis function checks if the REPL buffer has the name `ipython`. If it does, it\ncreates a floating window at the center of the Vim screen with specific size\nand styling. If not, it creates a horizontal split below the current window and\ntakes up 15 lines for the new window.\n\n\n# Add your own REPLs\n\nYou can add your own REPL meta by following this example:\n\n```lua\nfunction send_line_verbatim(lines)\n -- each line is a string\n return lines\nend\n\nfunction ipython_or_python()\n if vim.fn.executable 'ipython' == 1 then\n return { 'ipython', '--simple-prompt' }\n else\n return 'python'\n end\nend\n\nfunction ipython_or_python_formatter(lines)\n if vim.fn.executable 'ipython' == 1 then\n return yarepl.formatter.bracketed_pasting(lines)\n else\n return yarepl.formatter.trim_empty_lines(lines)\n end\nend\n\nmetas = {\n ipython_new = { cmd = { 'ipython', '--simple-prompt' }, formatter = send_line_verbatim },\n ipython_or_python = { cmd = ipython_or_python, formatter = ipython_or_python_formatter },\n}\n\n-- cmd can be three types: a string, a list of strings, or a function that\n-- returns either a string or list of strings.\n\n-- formatter is a function takes a list of string as an argument and returns a\n-- list of strings.\n```\n[Here is a more complex example for ghci, a haskell repl.](https://github.com/milanglacier/yarepl.nvim/issues/21)\n\nSome REPLs can distinguish between pasted text and text from the user manual\ninput by using prefix and suffix sequences, such as bracketed paste.\n\nFor modern REPLs with bracketed pasting support (which is usually the case), it\nis recommended to use `yarepl.formatter.bracketed_pasting`.\n\nHere are some tips for writing your own formatter function:\n\n1. You may want to add a new entry `\"\\r\"` at the end of the list to indicate\n the end of input.\n\n2. If your REPL cannot distinguish between copy-pasted text and text from user\n manual input, you may want to replace `\\t` with 4 or 8 spaces since sending\n a raw `\\t` may be interpreted as invoking completion.\n\n3. Do not include `\\n` in any line as the `chansend` function will\n automatically replace it with `\\0`.\n\n4. You may want to remove any empty lines from the input (a list of strings)\n since `chansend` function translates an empty string `\"\"` into `\"\\n\"`. For\n some REPLs without bracketed pasting support (such as Python), a plain\n `\"\\n\"` may be treated as the end of input, blocking the rest of the code in\n the same function.\n\n5. If your REPL cannot distinguish between copy-pasted text and text from user\n manual input and your REPL will do auto-indent for you, you may want to\n remove any leading spaces from each line to prevent double indentation.\n\n6. The returned list of strings will be sent to the `chansend` function for\n reference.\n\nThere's a `yarepl` helper function that allows you to quickly build a formatter\nfunction without having to write everything from scratch.\n\n```lua\n-- Calling this function will return a function that takes a list of strings as\n-- input and returns a list of strings. This can be used as the formatter function\n-- of meta.\n\n-- these are the default config\nyarepl.formatter.factory {\n -- Specifies whether to return tabs in the string as spaces.\n replace_tab_by_space = false,\n -- Specifies the number of spaces to replace the tab (if enabled).\n number_of_spaces_to_replace_tab = 8,\n -- For a list of strings containing more than one string:\n when_multi_lines = {\n -- The prefixing code sent to the repl firstly.\n open_code = '',\n -- The suffixing code sent to the repl finally.\n end_code = '\\r',\n -- Whether to remove empty lines from the list of strings.\n trim_empty_lines = false,\n -- Whether to remove leading spaces at the beginning of each line.\n remove_leading_spaces = false,\n -- If gsub_pattern and gsub_repl are not empty, `string.gsub` will\n -- be called with `gsub_pattern` and `gsub_repl` on each line. Note\n -- that you should use Lua pattern instead of Vim regex pattern.\n -- The gsub calls happen after `trim_empty_lines`,\n -- `remove_leading_spaces`, and `replace_tab_by_space`, and before\n -- prepending and appending `open_code` and `end_code`.\n gsub_pattern = '',\n gsub_repl = '',\n },\n -- For a list containing only one string:\n when_single_line = {\n -- The prefixing code sent to the repl firstly.\n open_code = '',\n -- The suffixing code sent to the repl finally.\n end_code = '\\r',\n -- the same as the specs of `when_multi_lines`\n gsub_pattern = '',\n gsub_repl = '',\n },\n os = {\n -- Some hacks for Windows. macOS and Linux users can simply ignore\n -- them. The default options are recommended for Windows user.\n windows = {\n -- Join the lines with `\\r` before sending to REPL.\n join_lines_with_cr = true,\n },\n },\n}\n\n-- `yarepl` provides two default formatters, which can be constructed by\n-- calling `yarepl.formatter.factory` with different arguments, like this:\n\nyarepl.formatter.trim_empty_lines = yarepl.formatter.factory {\n when_multi_lines = {\n trim_empty_lines = true,\n remove_leading_spaces = false,\n },\n}\n\nyarepl.formatter.bracketed_pasting = yarepl.formatter.factory {\n when_multi_lines = {\n open_code = '\\27[200~',\n end_code = '\\27[201~\\r',\n trim_empty_lines = false,\n remove_leading_spaces = false,\n },\n}\n```\n\n\n# Example keybinding setup\n\nHere is the keybindings setup from the maintainer:\n\n```lua\n-- The `run_cmd_with_count` function enables a user to execute a command with\n-- count values in keymaps. This is particularly useful for `yarepl.nvim`,\n-- which heavily uses count values as the identifier for REPL IDs.\nlocal function run_cmd_with_count(cmd)\n return function()\n vim.cmd(string.format('%d%s', vim.v.count, cmd))\n end\nend\n\n-- The `partial_cmd_with_count_expr` function enables users to enter partially\n-- complete commands with a count value, and specify where the cursor should be\n-- placed. This function is mainly designed to bind `REPLExec` command into a\n-- keymap.\nlocal function partial_cmd_with_count_expr(cmd)\n return function()\n -- is equivalent to \\21, we want to clear the range before next input\n -- to ensure the count is recognized correctly.\n return ':\\21' .. vim.v.count .. cmd\n end\nend\n\nlocal keymap = vim.api.nvim_set_keymap\nlocal bufmap = vim.api.nvim_buf_set_keymap\nlocal autocmd = vim.api.nvim_create_autocmd\n\n-- cs will be equivalent to `REPLStart aichat`\n-- 2cs will be equivalent to `2REPLStart aichat`, etc.\nkeymap('n', 'cs', '', {\n callback = run_cmd_with_count 'REPLStart aichat',\n desc = 'Start an Aichat REPL',\n})\n-- cf will be equivalent to `REPLFocus aichat`\n-- 2cf will be equivalent to `2REPLFocus aichat`, etc.\nkeymap('n', 'cf', '', {\n callback = run_cmd_with_count 'REPLFocus aichat',\n desc = 'Focus on Aichat REPL',\n})\nkeymap('n', 'ch', '', {\n callback = run_cmd_with_count 'REPLHide aichat',\n desc = 'Hide Aichat REPL',\n})\nkeymap('v', 'cr', '', {\n callback = run_cmd_with_count 'REPLSendVisual aichat',\n desc = 'Send visual region to Aichat',\n})\nkeymap('n', 'crr', '', {\n callback = run_cmd_with_count 'REPLSendLine aichat',\n desc = 'Send current line to Aichat',\n})\n-- `crap` will send a paragraph to the first aichat REPL.\n-- `2crap` will send a paragraph to the second aichat REPL. Note that\n-- `ap` is just an example and can be replaced with any text object or motion.\nkeymap('n', 'cr', '', {\n callback = run_cmd_with_count 'REPLSendOperator aichat',\n desc = 'Operator to Send text to Aichat',\n})\nkeymap('n', 'cq', '', {\n callback = run_cmd_with_count 'REPLClose aichat',\n desc = 'Quit Aichat',\n})\nkeymap('n', 'cc', 'REPLCleanup', {\n desc = 'Clear aichat REPLs.',\n})\n\n-- `ce How to current win id in neovim?`: This keymap executes a\n-- command in `aichat` with the specified count value.\nkeymap('n', 'ce', '', {\n callback = partial_cmd_with_count_expr 'REPLExec $aichat ',\n desc = 'Execute command in aichat',\n expr = true,\n})\n\nlocal ft_to_repl = {\n r = 'radian',\n rmd = 'radian',\n quarto = 'radian',\n markdown = 'radian',\n ['markdown.pandoc'] = 'radian',\n python = 'ipython',\n sh = 'bash',\n REPL = '',\n}\n\nautocmd('FileType', {\n pattern = { 'quarto', 'markdown', 'markdown.pandoc', 'rmd', 'python', 'sh', 'REPL' },\n desc = 'set up REPL keymap',\n callback = function()\n local repl = ft_to_repl[vim.bo.filetype]\n bufmap(0, 'n', 'rs', '', {\n callback = run_cmd_with_count('REPLStart ' .. repl),\n desc = 'Start an REPL',\n })\n bufmap(0, 'n', 'rf', '', {\n callback = run_cmd_with_count 'REPLFocus',\n desc = 'Focus on REPL',\n })\n bufmap(0, 'n', 'rv', 'Telescope REPLShow', {\n desc = 'View REPLs in telescope',\n })\n bufmap(0, 'n', 'rh', '', {\n callback = run_cmd_with_count 'REPLHide',\n desc = 'Hide REPL',\n })\n bufmap(0, 'v', 's', '', {\n callback = run_cmd_with_count 'REPLSendVisual',\n desc = 'Send visual region to REPL',\n })\n bufmap(0, 'n', 'ss', '', {\n callback = run_cmd_with_count 'REPLSendLine',\n desc = 'Send current line to REPL',\n })\n -- `sap` will send the current paragraph to the\n -- buffer-attached REPL, or REPL 1 if there is no REPL attached.\n -- `2sap` will send the paragraph to REPL 2. Note that `ap` is\n -- just an example and can be replaced with any text object or motion.\n bufmap(0, 'n', 's', '', {\n callback = run_cmd_with_count 'REPLSendOperator',\n desc = 'Operator to send to REPL',\n })\n bufmap(0, 'n', 'rq', '', {\n callback = run_cmd_with_count 'REPLClose',\n desc = 'Quit REPL',\n })\n bufmap(0, 'n', 'rc', 'REPLCleanup', {\n desc = 'Clear REPLs.',\n })\n bufmap(0, 'n', 'rS', 'REPLSwap', {\n desc = 'Swap REPLs.',\n })\n bufmap(0, 'n', 'r?', '', {\n callback = run_cmd_with_count 'REPLStart',\n desc = 'Start an REPL from available REPL metas',\n })\n bufmap(0, 'n', 'ra', 'REPLAttachBufferToREPL', {\n desc = 'Attach current buffer to a REPL',\n })\n bufmap(0, 'n', 'rd', 'REPLDetachBufferToREPL', {\n desc = 'Detach current buffer to any REPL',\n })\n -- `3re df.describe()`: This keymap executes the specified\n -- command in REPL 3.\n bufmap(0, 'n', 're', '', {\n callback = partial_cmd_with_count_expr 'REPLExec ',\n desc = 'Execute command in REPL',\n expr = true,\n })\n end,\n})\n```\n\nThe `run_cmd_with_count` function ensures that any numeric prefix given to a\nkeybinding, such as `3rs`, `2s`, and `5cr`,\nis passed to the corresponding command. For instance, `2REPLStart aichat` is\nequivalent to `2cs`, and `3REPLSendOperator` is equivalent to\n`3s`.\n\nWith the keybinding setup, prefixing keybindings with `c` ensures that\nthe text is always sent to the `aichat` REPL, a REPL for chatgpt. The\nmaintainer requires a global hotkey for easily talking with chatgpt.\n\nFor maximum flexibility with other programming languages, the maintainer\ndesires the ability to easily switch between two modes:\n\n1. Sending text from multiple files to a REPL via `2s`, regardless\n of which buffer the maintainer is visiting. This guarantees that the text is\n always sent to `RPEL 2`.\n\n2. Sending text to a dedicated REPL for each buffer. To avoid the hassle of\n remembering the exact ID associated with the desired REPL, the maintainer\n can use `ra` to attach the current buffer to a REPL.\n Subsequently, the `s` key can be directly used to send the text\n to the desired REPL.\n\n# Telescope Integration\n\n`yarepl` has integrated with Telescope and can be enabled by adding the\nfollowing line to your config:\n\n```lua\nrequire('telescope').load_extension 'REPLShow'\n```\n\nOnce added, you can use `Telescope REPLShow` to preview the active REPL\nbuffers. If you are using the default Telescope configuration, `` opens a\nnew tab for the selected REPL, `` generates a vertical split window for\nthe chosen REPL, and `` creates a horizontal split window for your\nselected REPL.\n\n# Set up project-level REPLs\n\nYou may want to have the ability to control the REPL metas at the project\nlevel. For example, you may want to open `ipython` installed in a conda\nenvironment for one project and a different `ipython` installed in another\nconda environment for another project.\n\nOne way to achieve this is to:\n\n- Enable the built-in `exrc`, which requires `nvim 0.9` for security reasons.\n\nTo enable `exrc`, add the following line to your Neovim config:\n\n```lua\nvim.o.exrc = 1\n```\n\nThen, configure `yarepl` like so:\n\n```lua\nvim.g.yarepl_ipython_paths = vim.g.yarepl_ipython_paths or {}\nlocal yarepl = require 'yarepl'\n\nrequire('yarepl').setup {\n metas = {\n ipython = {\n cmd = function()\n local cwd = vim.fn.getcwd()\n if vim.g.yarepl_ipython_paths and vim.g.yarepl_ipython_paths[cwd] then\n return vim.g.yarepl_ipython_paths[cwd]\n else\n return 'ipython'\n end\n end,\n },\n },\n}\n```\n\nNow, in the project root directory `~/projects/project1`, create a file\ncalled `.nvim.lua` with the following lines:\n\n```lua\nlocal cwd = vim.fn.getcwd()\n\nif vim.g.yarepl_ipython_paths then\n vim.g.yarepl_ipython_paths[cwd] = '~/mambaforge/envs/a-conda-env/bin/ipython'\nelse\n vim.g.yarepl_ipython_paths = {\n [cwd] = '~/mambaforge/envs/a-conda-env/bin/ipython',\n }\nend\n```\n\nThe first time you open `project1`, Neovim will prompt you to decide whether\nyou want to load the `.nvim.lua` file. Please allow it.\n\n**Note:** The `.nvim.lua` file will be automatically loaded only once when\nNeovim starts. Thus, if you switch working directories during the time Neovim\nis running, the `.nvim.lua` file won't be loaded at the new working directory.\nTo manually load the `.nvim.lua` file after switching to a new working\ndirectory, try `:luafile .nvim.lua`.\n\n# Create persistent REPLs in tmux\n\nIf you would like to maintain a persistent REPL process even after exiting\nneovim, you can utilize tmux. To achieve this, the following configuration\ncreates a REPL meta named `ipy_tmux` that attaches to a tmux session named\n`ipython`. If the session does not exist, a new tmux session named `ipython` is\ncreated, and an `ipython` REPL is started.\n\n```lua\nmetas = {\n ipy_tmux = {\n cmd = 'tmux attach -t ipython || tmux new -s ipython ipython',\n formatter = yarepl.formatter.bracketed_pasting,\n },\n}\n```\n\n# FAQ\n\n## How do I avoid clutter from the bufferline plugin?\n\nIf you are using a bufferline plugin and do not want the REPL buffers to\nclutter your bufferline, pass `buflisted = false` in the `setup` function.\n\nIn case you have unlisted the REPLs and need to view the running ones, use\n`Telescope REPLShow`.\n\n## REPLSendVisual is not functioning properly\n\nRefer to [REPLSendVisual](#replsendvisual)\n\n# Limitations\n\n- Currently, `yarepl` only supports sending entire lines to REPL. This means\n that no matter what the motion or visual range is, it will always send the\n whole line to the REPL.\n\n# Acknowledgements\n\n- [iron.nvim](https://github.com/Vigemus/iron.nvim)\n- [toggleterm.nvim](https://github.com/akinsho/toggleterm.nvim)\n","dotfyleShieldAddedAt":null,"stars":63,"lastSyncedAt":"2023-12-01T02:25:33.500Z","addedLastWeek":0}}}]}}]