vim-iced help

vim-iced.txt      Clojure interactive development environment for Vim8/Neovim

 

Version: 2.1.3

Author : Masashi Iizuka <liquidz.uo+vim@gmail.com>

License: MIT LICENSE

 

==============================================================================

@CONTENTS                                                    vim-iced-contents

 

  Introduction                 vim-iced-introduction

  Install                      vim-iced-install

    Iced command               vim-iced-install-command

    Manual Install             vim-iced-install-manually

      Leiningen                vim-iced-manual-leiningen

      Boot                     vim-iced-manual-boot

      shadow-cljs              vim-iced-manual-shadow-cljs

    Boost by Python            vim-iced-install-python

    Docker                     vim-iced-install-docker

  REPL Connection              vim-iced-repl-connection

  ClojureScript                vim-iced-clojurescript

    Piggieback                 vim-iced-piggieback

    FigwheelMain               vim-iced-figwheel-main

    shadow-cljs                vim-iced-shadow-cljs

  Evaluating                   vim-iced-evaluating

    Stdout Buffer              vim-iced-stdout-buffer

  Testing                      vim-iced-testing

    Plain nREPL                vim-iced-testing-plain-nrepl

  Debugging                    vim-iced-debugging

    Tracing function calls     vim-iced-debugging-tracing-function-calls

    Browsing tapped values     vim-iced-debugging-browsing-tapped-values

    Floating Window            vim-iced-debugging-floating-window

  Skeleton                     vim-iced-skeleton

  Tag Jump                     vim-iced-tag-jump

  Editing S-exp                vim-iced-editing-s-exp

    Formatting                 vim-iced-formatting

    Indenting                  vim-iced-indenting

    Refactoring                vim-iced-refactoring

  Sideloader                   vim-iced-sideloader

  Interface                    vim-iced-interface

    Commands                   vim-iced-commands

    Functions                  vim-iced-functions

    Key Mappings               vim-iced-key-mappings

  Customizing                  vim-iced-customizing

    Stdout buffer              vim-iced-customizing-stdout-buffer

    Formatter                  vim-iced-customizing-formatter

    Indent rules               vim-iced-customizing-indents

      Tonsky's rule            vim-iced-customizing-tonsky-rule

    Documents                  vim-iced-customizing-documents

      Auto document            vim-iced-customizing-auto-document

    Auto indent                vim-iced-customizing-auto-indent

    Signs                      vim-iced-customizing-signs

    Command palettes           vim-iced-customizing-palette

    Hooks                      vim-iced-customizing-hooks

    Popup window               vim-iced-customizing-popup-window

    Sideloader                 vim-iced-customizing-sideloader

    Default keys               vim-iced-customizing-default-keys

  Changelog                    vim-iced-changelog

 

==============================================================================

@INTRODUCTION                                            vim-iced-introduction

 

  Clojure interactive development environment for Vim8/Neovim.

 

  Requirement:

  - Vim 8.1.0614 or later, Neovim 0.4.0 or later

  - Clojure 1.8 or later

    1.10 or later is recommended

  - For Leiningen user

    2.8.2 or later

 

  Latest Version:

  - https://github.com/liquidz/vim-iced

 

==============================================================================

@INSTALL                                                      vim-iced-install

 

  Vim plugin dependencies:

 

  - vim-sexp

    https://github.com/guns/vim-sexp

  - selector

    One of following is required when selecting multiple candidates

    - ctrlp.vim

      https://github.com/ctrlpvim/ctrlp.vim

    - fzf

      https://github.com/junegunn/fzf

    - vim-clap

      https://github.com/liuchengxu/vim-clap

 

------------------------------------------------------------------------------

@ICED COMMAND                                         vim-iced-install-command

 

  vim-iced provides iced command to use vim-iced easily.

 

  Add $PATH environment variable to /path/to/vim-iced/bin.

  E.g. export PATH=$PATH:~/src/github.com/liquidz/vim-iced/bin

 

  NOTE:

    iced command has a feature to detect a use of ClojureScript.

    But by default, it may be a false positive because of simple string match.

 

    In this case, you can use more accurate checks with Babashka.

    (Optional and Limited for Leiningen and Clojure CLI only)

    iced command will use it automatically when bb command exists.

 

  WARNING:

    Do not copy bin/iced file to your $PATH.

    iced command references /path/to/vim-iced/deps.edn for Clojure CLI.

    So the copied iced command cannot reference it.

 

  To show help, run iced help .

 

------------------------------------------------------------------------------

@MANUAL INSTALL                                      vim-iced-install-manually

 

 

@                                                    vim-iced-manual-leiningen

LEININGEN

 

  $HOME/.lein/profile.clj

  {:user
   {:dependencies [[nrepl "0.7.0"]
                   [iced-nrepl "1.0.4"]
                   [cider/cider-nrepl "0.25.3"]]
    :repl-options {:nrepl-middleware [cider.nrepl/wrap-classpath
                                      cider.nrepl/wrap-clojuredocs
                                      cider.nrepl/wrap-complete
                                      cider.nrepl/wrap-debug
                                      cider.nrepl/wrap-format
                                      cider.nrepl/wrap-info
                                      cider.nrepl/wrap-macroexpand
                                      cider.nrepl/wrap-ns
                                      cider.nrepl/wrap-out
                                      cider.nrepl/wrap-spec
                                      cider.nrepl/wrap-test
                                      cider.nrepl/wrap-trace
                                      cider.nrepl/wrap-undef
                                      cider.nrepl/wrap-xref
                                      iced.nrepl/wrap-iced]}
    :plugins [[refactor-nrepl "2.5.0"]]}}

 

@                                                         vim-iced-manual-boot

BOOT

 

  $HOME/.boot/profile.boot

  (require (quote boot.repl))

  (swap! boot.repl/*default-dependencies* concat
    '[[refactor-nrepl "2.5.0"]
      [cider/cider-nrepl "0.25.3"]
      [iced-nrepl "1.0.4"]])

  (swap! boot.repl/*default-middleware* concat
    '[cider.nrepl/wrap-classpath
      cider.nrepl/wrap-clojuredocs
      cider.nrepl/wrap-complete
      cider.nrepl/wrap-debug
      cider.nrepl/wrap-format
      cider.nrepl/wrap-info
      cider.nrepl/wrap-macroexpand
      cider.nrepl/wrap-ns
      cider.nrepl/wrap-out
      cider.nrepl/wrap-spec
      cider.nrepl/wrap-test
      cider.nrepl/wrap-trace
      cider.nrepl/wrap-undef
      cider.nrepl/wrap-xref
      refactor-nrepl.middleware/wrap-refactor
      iced.nrepl/wrap-iced])

@                                                  vim-iced-manual-shadow-cljs

SHADOW-CLJS

 

  WARNING: iced command does not support shadow-cljs currently.

 

  shadow-cljs.edn

  {
   :dependencies [[refactor-nrepl "2.5.0"]
                  [cider/cider-nrepl "0.25.3"]
                  [iced-nrepl "1.0.4"]]

   :nrepl {:cider false
           :middleware [cider.nrepl/wrap-classpath
                        cider.nrepl/wrap-clojuredocs
                        cider.nrepl/wrap-complete
                        cider.nrepl/wrap-debug
                        cider.nrepl/wrap-format
                        cider.nrepl/wrap-info
                        cider.nrepl/wrap-macroexpand
                        cider.nrepl/wrap-ns
                        cider.nrepl/wrap-out
                        cider.nrepl/wrap-spec
                        cider.nrepl/wrap-test
                        cider.nrepl/wrap-trace
                        cider.nrepl/wrap-undef
                        cider.nrepl/wrap-xref
                        refactor-nrepl.middleware/wrap-refactor
                        iced.nrepl/wrap-iced]}
  }

  To start CLJS REPL, see vim-iced-shadow-cljs.

 

==============================================================================

@BOOST BY PYTHON                                       vim-iced-install-python

 

  vim-iced does not require if_python3 basically,

  and all communication with nrepl is done by pure vim script.

 

  But pure vim script is slow.

  So vim-iced uses if_python3 to boost process if it is enabled.

 

==============================================================================

@DOCKER                                                vim-iced-install-docker

 

  When you are connecting to nREPL in docker container, various paths will be

  paths in the docker container.

  There is a g:iced#nrepl#path_translation option to translate these paths.

 

  In actual use, it is recommended to define the option

  in the project-specific configuration file by vim-localrc.

  https://github.com/thinca/vim-localrc

 

  E.g. /path/to/your/project/root/.local.vimrc

    let g:iced#nrepl#path_translation = {
          \ '/tmp': expand('<sfile>:p:h'),
          \ '/root': $HOME,
          \ }

==============================================================================

@REPL CONNECTION                                      vim-iced-repl-connection

 

  REPL needs to be activated beforehand.

  - nREPL

    - iced repl to start REPL

      iced command must be installed.

      See vim-iced-install-command.

  - pREPL

    - clj -J-Dclojure.server.repl="{:port 5555 :accept clojure.core.server/io-prepl}"

  - Socket REPL

    - e.g. Babashka

      - bb --socket-repl 5555

 

  If you don't want to launch REPL externally,

  vim-iced provides following ways to lancun REPL internally.

  - :IcedJackIn to launch iced repl internally

  - :IcedInstantConnect to launch a REPL internally.

 

  :IcedConnect to connect nREPL.

  :IcedConnectPrepl to connect pREPL.

  :IcedConnectSocketRepl to connect Socket REPL.

  If not connected at the time of evaluation,

  vim-iced will connect automatically using '.nrepl-port' file.

 

  :IcedDisconnect to disconnect from REPL.

 

==============================================================================

@CLOJURE SCRIPT                                         vim-iced-clojurescript

 

  Supports following environment currently.

  - figwheel-main

    0.2.0 or later is required.

  - figwheel-sidecar

  - shadow-cljs

 

  :IcedStartCljsRepl to start cljs-repl.

  :IcedQuitCljsRepl to quit it.

  :IcedCycleSession to cycle clj/cljs session.

 

  For other environments, you can use :IcedCljsRepl command.

 

------------------------------------------------------------------------------

@PIGGIEBACK                                                vim-iced-piggieback

 

  Supporting ClojureScript requires nrepl/piggieback.

  - https://github.com/nrepl/piggieback

 

  iced command will inject piggieback dependency automatically,

  when project configuration files contains org.clojure/clojurescript.

  Or you can use --with-cljs option to inject piggieback explicitly.

  iced repl --with-cljs

------------------------------------------------------------------------------

@FIGWHEEL MAIN                                          vim-iced-figwheel-main

 

  To start CLJS REPL with figwheel-main, you need to specify {build-id}.

  E.g. :IcedCljsRepl (figwheel.main.api/repl-env "build-id")

 

  Via :IcedStartCljsRepl command, you can specify {build-id} as follows.

  :IcedStartCljsRepl figwheel-main build-id

 

------------------------------------------------------------------------------

@SHADOW-CLJS                                              vim-iced-shadow-cljs

 

  To start CLJS REPL with shadow-cljs, you need 3 steps.

 

  1. Add definitions to shadow-cljs.edn

    See details: vim-iced-manual-shadow-cljs

 

  2. Start to watch

    $ shadow-cljs watch {build-id}

 

  3. Connect and start cljs-repl

    - :IcedConnect

    - :IcedStartCljsRepl shadow-cljs {build-id}

 

  If you would like to start CLJS REPL by hand, you can do it as follows.

  :IcedEvalRepl (shadow.cljs.devtools.api/repl :build-id)

 

==============================================================================

@EVALUATING                                                vim-iced-evaluating

 

  :IcedEval is the simplest way to evaluate forms.

  But working with {vim-sexp} is the best.

  See details to work with {vim-sexp}<Plug>(iced_eval)

 

  There are 3 default key bindings to evaluate s-expression.

  - <Leader>ei : Evaluate inner element

  - <Leader>ee : Evaluate outer list

  - <Leader>et : Evaluate outer top list

  c.f. vim-iced-customizing-default-keys

 

  Specific evaluation range(| means cursor position):

  ;; <------------et----------->
     (defn greet []
       (println "|hello world"))
  ;;            <-----ei----->
  ;;   <----------ee---------->

  See https://liquidz.github.io/vim-iced/#configuration_evaluation

 

------------------------------------------------------------------------------

@STDOUT BUFFER                                          vim-iced-stdout-buffer

 

  Standard outputs will be outputted to dedicated buffer.

  :IcedStdoutBufferOpen to open it.

  :IcedStdoutBufferClear to clear all outputted lines.

 

  If you show buffer content in another application or display,

  g:iced#buffer#stdout#file option is available for writing file.

 

==============================================================================

@TESTING                                                      vim-iced-testing

 

  vim-iced provides following test commands.

  - :IcedTestUnderCursor

  - :IcedTestNs

  - :IcedTestAll

  - :IcedTestRedo

  - :IcedTestSpecCheck

  - :IcedTestRerunLast

 

  When tests are failed, vim-iced sets error positions to quickfix.

  :cwindow command enables you to show this information.

 

  To show quickfix automatically, following autocmd is useful.

  aug VimIcedAutoOpenQuickfix
    au!
    au QuickFixCmdPost vim-iced cwindow
  aug END

------------------------------------------------------------------------------

@PLAIN NREPL                                      vim-iced-testing-plain-nrepl

 

  vim-iced basically requires nREPL with some middlewares.

  But in some case, you may need to use plain nREPL such as babashka.nrepl.

  - https://github.com/borkdude/babashka/blob/master/doc/repl.md#nrepl

 

  In this case, vim-iced provides simple test integration which has less

  functionality than cider-nrepl's one.

 

  To use this simple test integration, you don't need to recognize whether

  your nREPL is plain or not.

  Following commands are also support simple test integration,

  so you just execute these commands as usual.

  

  - :IcedTestUnderCursor

  - :IcedTestNs

  - :IcedTestAll

    NOTE: :IcedTestAll depends on current namespace.

          (e.g. foo.core will search all vars in foo.*).

          So it's still not really the whole test.

 

==============================================================================

@DEBUGGING                                                  vim-iced-debugging

 

  vim-iced supports cider's #dbg and #break reader literals.

  The easiest way is to put #dbg to your code, and evaluate it.

  (defn fib [n]
    #dbg (loop [a 0 b 1 n n]
           (if (<= n 0)
             a
             (recur b (+ a b) (dec n)))))

  Related options:

  - g:iced#debug#value_max_length

 

------------------------------------------------------------------------------

@TRACING FUNCTION CALLS              vim-iced-debugging-tracing-function-calls

 

  vim-iced provides 2 ways for tracing function calls.

  - :IcedToggleTraceVar

  - :IcedToggleTraceNs

 

  Traced result will be displayed in stdout buffer.

  - vim-iced-stdout-buffer

 

------------------------------------------------------------------------------

@BROWSING TAPPED VALUES              vim-iced-debugging-browsing-tapped-values

 

  WARNING: To use tap>, Clojure 1.10.0 or later is required

 

  If you have a big data structure and want to dig into it,

  browsing tapped values is useful.

 

  When you evaluate (tap> YOUR_DATA):IcedBrowseTapped shows tapped values.

  Select the value you want to dig into, then browsing value start.

  See :IcedBrowseTapped for browsing key details.

 

  All tapped values are stored in memory.

  So if you would like to delete them, execute :IcedClearTapped command.

 

------------------------------------------------------------------------------

@FLOATING WINDOW                            vim-iced-debugging-floating-window

 

  vim-iced supports both of popup window in Vim

  and floating window in Neovim.

  This feature is very experimental, but works.

 

  If your environment meets followings,

  debugging information will be shown in floating window automatically.

  - Vim 8.1 patch 1-1408 or later

  - Neovim 0.4.0 or later

 

  Related options:

  - g:iced#popup#time

  - g:iced#popup#max_height

  - g:iced#popup#neovim#winhighlight

  - g:iced#popup#neovim#style

 

==============================================================================

@SKELETON                                                    vim-iced-skeleton

 

  vim-iced provides code skeleton when you open new clojure files.

  Currently, these extensions are supported.

  - *.clj

  - *.cljs

  - *.cljc

 

==============================================================================

@TAG JUMP                                                    vim-iced-tag-jump

 

  :IcedDefJump to jump to definition.

  To jump back, you can use default key mapping(<C-t>).

 

==============================================================================

@EDITING S-EXP                                          vim-iced-editing-s-exp

 

  Provides slurp and barf function.

  - :IcedSlurp

  - :IcedBarf

 

------------------------------------------------------------------------------

@FORMATTING                                                vim-iced-formatting

 

  Provides following functions.

  - :IcedFormat

  - :IcedFormatAll

 

  vim-sexp also provides formatting codes function.

  If you want to use vim-iced's formatting function,

  you should define {g:sexp_mappings} as follows.

  let g:sexp_mappings = {'sexp_indent': '', 'sexp_indent_top': ''}

  See also vim-iced-customizing-formatter.

 

------------------------------------------------------------------------------

@INDENTING                                                  vim-iced-indenting

 

  vim-iced provides 'cljfmt' based auto indentation,

  and it is enabled by default.

 

  If you don't use vim-iced's auto indentation,

  you can disable it by g:iced_enable_auto_indent variable.

  let g:iced_enable_auto_indent = v:false

------------------------------------------------------------------------------

@REFACTORING                                              vim-iced-refactoring

 

  Provides following functions powered by refactor-nrepl.

  - :IcedCleanNs (<Plug>(iced_clean_ns))

  - :IcedCleanAll (<Plug>(iced_clean_all))

  - :IcedAddMissing (<Plug>(iced_add_missing))

  - :IcedThreadFirst (<Plug>(iced_thread_first))

  - :IcedThreadLast (<Plug>(iced_thread_last))

  - :IcedExtractFunction (<Plug>(iced_extract_function))

  - :IcedAddArity (<Plug>(iced_add_arity))

  - :IcedMoveToLet (<Plug>(iced_move_to_let))

 

 

==============================================================================

@SIDELOADER                                                vim-iced-sideloader

 

  WARNING: base64 command is required to use sideloader.

 

  Sideloader is a new feature from nREPL 0.7, and enables injecting code

  remotely in a running server on demand.

 

  vim-iced provides following commands for sideloader:

  - :IcedStartSideloader.

  - :IcedStoptSideloader.

 

  When nREPL requires to look up some codes,

  vim-iced will search in g:iced#source_root.

 

  It is assumed that sources under g:iced#source_root is managed by

  tools such as ghq.

  - https://github.com/x-motemen/ghq

 

  vim-iced will use find or fd as a searching file program.

  - https://github.com/sharkdp/fd

 

==============================================================================

@INTERFACE                                                  vim-iced-interface

 

------------------------------------------------------------------------------

@COMMANDS                                                    vim-iced-commands

 

@                                                                 :IcedConnect

:IcedConnect [{port}]

  Make connection to nREPL.

  If {port} is not passed, {port} is detected by '.nrepl-port' automatically.

  Key is mapped to <Plug>(iced_connect).

 

@                                                       :IcedConnectSocketRepl

:IcedConnectSocketRepl {port}

  Make connection to socket REPL.

  {port} is required.

 

@                                                            :IcedConnectPrepl

:IcedConnectPrepl {port}

  Make connection to pREPL.

  {port} is required.

  This connection is based on socket repl connection.

 

@                                                              :IcedDisconnect

:IcedDisconnect

  Disconnect from nREPL.

  Automatically disconnected at leaving vim.

  Key is mapped to <Plug>(iced_disconnect).

 

@                                                               :IcedReconnect

:IcedReconnect

  Disconnect from nREPL, and make connection to nREPL again.

  Previous sessions are closed.

  Key is mapped to <Plug>(iced_reconnect).

 

@                                                               :IcedInterrupt

:IcedInterrupt

  Interrupt some code evaluation in current session.

  Key is mapped to <Plug>(iced_interrupt).

 

@                                                            :IcedInterruptAll

:IcedInterruptAll

  Interrupt code evaluation in all sessions.

  Key is mapped to <Plug>(iced_interrupt_all).

 

@                                                                  :IcedJackIn

:IcedJackIn

  Start REPL and connect to it.

  REPL is launched as job internally.

  See g:iced#nrepl#connect#jack_in_command for the concrete command

  to start REPL.

  Key is mapped to <Plug>(iced_jack_in).

 

@                                                          :IcedInstantConnect

:IcedInstantConnect [{target}]

  Start instant REPL and connect to it.

  REPL is launched as job internally.

 

  Supports follows {target}:

  - nrepl or empty

    Launch iced repl --instant

  - babashka

    Launch babashka REPL

    See also g:iced#repl#babashka_repl_type option.

 

  Key is mapped to <Plug>(iced_instant_connect).

 

@                                                                :IcedCljsRepl

:IcedCljsRepl {form}

  Start CLJS REPL via user specified code.

  The code will be passed to cider.piggieback/cljs-repl.

 

  E.g.

  ;; figwheel-main
  :IcedCljsRepl (figwheel.main.api/repl-env "app")

  ;; figwheel-sidecar
  :IcedCljsRepl (figwheel-sidecar.repl-api/repl-env)

@                                                           :IcedStartCljsRepl

:IcedStartCljsRepl [{env}]

  Start CLJS REPL with specified environment.

  REPL session changes to 'cljs.user' namespace.

  If {env} is not passed, g:iced#cljs#default_env is used.

 

  Supports following environment currently.

  - figwheel-sidecar

  - figwheel-main

  - shadow-cljs

 

  Key is mapped to <Plug>(iced_start_cljs_repl).

 

@                                                            :IcedQuitCljsRepl

:IcedQuitCljsRepl

  Quit CLJS REPL.

  REPL session changes to initial namespace.

  Key is mapped to <Plug>(iced_quit_cljs_repl).

 

@                                                            :IcedCycleSession

:IcedCycleSession

  Cycle clj/cljs session.

  Error occurs when CLJS session does not exist.

 

@                                                                    :IcedEval

:IcedEval {form}

  Evaluate {form} in current session.

  See details: <Plug>(iced_eval)

 

@                                                                  :IcedEvalNs

:IcedEvalNs

  Evaluate ns form in current session.

  Key is mapped to <Plug>(iced_eval_ns)

 

@                                                              :IcedEvalVisual

:IcedEvalVisual

  Evaluate selected form in current session.

  Key is mapped to <Plug>(iced_eval_visual)

 

@                                                                 :IcedRequire

:IcedRequire

  Load current file in current session.

  Key is mapped to <Plug>(iced_require).

 

@                                                              :IcedRequireAll

:IcedRequireAll

  Require and reload current file in current session.

  Key is mapped to <Plug>(iced_require_all).

 

@                                                                   :IcedUndef

:IcedUndef [{symbol}]

  Undefine {symbol} in current namespace.

  If {symbol} is not passed, symbol under cursor is used.

  Key is mapped to <Plug>(iced_undef).

 

@                                                            :IcedUndefAllInNs

:IcedUndefAllInNs [{ns}]

  Undefine all symbols in {ns}.

  If {ns} is not passed, current namespace is used.

  Key is mapped to <Plug>(iced_undef_all_in_ns).

 

@                                                        :IcedEvalOuterTopList

:IcedEvalOuterTopList

  Work same as <Plug>(iced_eval)<Plug>(sexp_outer_top_list),

  without scrolling.

  Key is mapped to <Plug>(iced_eval_outer_top_list).

 

@                                                              :IcedEvalAtMark

:IcedEvalAtMark

  NOTE: Type a key to specify the mark after executing this command.

  Evaluate the outer list (not outer top list) on the specified mark.

  Key is mapped to <Plug>(iced_eval_at_mark).

 

@                                                    :IcedEvalLastOuterTopList

:IcedEvalLastOuterTopList

  Re-evaluate the outer top list which is evaluated last.

  Last evaluated list is marked to g:iced#eval#mark_at_last.

  Key is mapped to <Plug>(iced_eval_last_outer_top_list).

 

@                                                               :IcedPrintLast

:IcedPrintLast

  Open a window, and show last evaluated value.

  Key is mapped to <Plug>(iced_print_last).

 

@                                                    :IcedMacroExpandOuterList

:IcedMacroExpandOuterList

  Work same as <Plug>(iced_macroexpand)<Plug>(sexp_outer_list),

  without scrolling.

  Key is mapped to <Plug>(iced_macroexpand_outer_list).

 

@                                                   :IcedMacroExpand1OuterList

:IcedMacroExpand1OuterList

  Work same as <Plug>(iced_macroexpand_1)<Plug>(sexp_outer_list),

  without scrolling.

  Key is mapped to <Plug>(iced_macroexpand_1_outer_list).

 

@                                                         :IcedTestUnderCursor

:IcedTestUnderCursor

  Run test under cursor.

 

  If the var under cursor does not contain :test metadata

  and current ns doesn't end with "-test",

  vim-iced searches test vars in corresponding test ns and run them.

  Target test vars include original var name in its name.

 

  Key is mapped to <Plug>(iced_test_under_cursor).

 

@                                                           :IcedTestRerunLast

:IcedTestRerunLast

  Run last test again.

  Key is mapped to <Plug>(iced_test_rerun_last).

 

@                                                           :IcedTestSpecCheck

:IcedTestSpecCheck [{num-tests}]

  Run clojure.spec.test.alpha/check for the function under cursor.

  NOTE: Adding test.check dependency is required.

        https://github.com/clojure/test.check

 

  If {num-tests} is not passed, g:iced#test#spec_num_tests is used.

  Key is mapped to <Plug>(iced_test_spec_check).

 

@                                                          :IcedTestBufferOpen

:IcedTestBufferOpen

  Open test result buffer.

  Key is mapped to <Plug>(iced_test_buffer_open).

 

@                                                                  :IcedTestNs

:IcedTestNs

  Run tests in current namespace.

  Key is mapped to <Plug>(iced_test_ns).

 

@                                                                 :IcedTestAll

:IcedTestAll

  Run all tests in current project.

  Key is mapped to <Plug>(iced_test_all).

 

@                                                                :IcedTestRedo

:IcedTestRedo

  Re run failed tests.

  Key is mapped to <Plug>(iced_test_redo).

 

@                                                        :IcedStdoutBufferOpen

:IcedStdoutBufferOpen

  Open stdout buffer.

  Key is mapped to <Plug>(iced_stdout_buffer_open).

 

@                                                       :IcedStdoutBufferClear

:IcedStdoutBufferClear

  Clear all lines in stdout buffer.

  Key is mapped to <Plug>(iced_stdout_buffer_clear).

 

@                                                       :IcedStdoutBufferClose

:IcedStdoutBufferClose

  Close stdout buffer window.

  Key is mapped to <Plug>(iced_stdout_buffer_close).

 

@                                                                 :IcedDefJump

:IcedDefJump

  Jump cursor to definition of symbol under cursor.

  Key is mapped to <Plug>(iced_def_jump).

 

@                                                                  :IcedOpenNs

:IcedOpenNs {ns-name}

  Open a file corresponding to the specified {ns-name}.

  If {ns-name} does not exist, make sure you open a file with a pseudo path.

 

@                                                        :IcedBrowseReferences

:IcedBrowseReferences

  Browse positions referencing the form under cursor.

  Results are set to location-list.

 

@                                                      :IcedBrowseDependencies

:IcedBrowseDependencies

  Browse positions depending on the form under cursor.

  Results are set to location-list.

 

@                                                     :IcedBrowseVarReferences

:IcedBrowseVarReferences

  Browse positions referencing the var under cursor.

  Results are set to location-list.

 

@                                                   :IcedBrowseVarDependencies

:IcedBrowseVarDependencies

  Browse positions depending on the var under cursor.

  Results are set to location-list.

 

@                                                            :IcedDocumentOpen

:IcedDocumentOpen [{symbol}]

  Open a window, and show documents for {symbol}.

  If {symbol} is not passed, symbol under cursor is used.

  Key is mapped to <Plug>(iced_document_open).

 

@                                                       :IcedDocumentPopupOpen

:IcedDocumentPopupOpen [{symbol}]

  Open a popup window, and show documents for {symbol}.

  If {symbol} is not passed, symbol under cursor is used.

  If popup is not supported, :IcedDocumentOpen is called.

  Key is mapped to <Plug>(iced_document_popup_open).

 

@                                                            :IcedFormDocument

:IcedFormDocument

  Echo one-line document for form under cursor.

  This is useful to show document while editing codes.

  See details <Plug>(iced_form_document).

 

@                                                             :IcedUseCaseOpen

:IcedUseCaseOpen [{symbol}]

  Open a window, and show usecase for {symbol}.

  If {symbol} is not passed, symbol under cursor is used.

  When several usecases are found, :IcedNextUseCase and :IcedPrevUseCase

  commands are useful to show next or previous usecases.

  Key is mapped to <Plug>(iced_use_case_open).

 

@                                                             :IcedNextUseCase

:IcedNextUseCase

  Show next usecase in a window if there is.

  See also :IcedUseCaseOpen command.

  Key is mapped to <Plug>(iced_next_use_case).

 

@                                                             :IcedPrevUseCase

:IcedPrevUseCase

  Show previous usecase in a window if there is.

  See also :IcedUseCaseOpen command.

  Key is mapped to <Plug>(iced_prev_use_case).

 

@                                                           :IcedDocumentClose

:IcedDocumentClose

  Close document window.

  Key is mapped to <Plug>(iced_document_close).

 

@                                                              :IcedSourceShow

:IcedSourceShow [{symbol}]

  Open a window, and show source codes for {symbol}

  If {symbol} is not passed, symbol under cursor is used.

  See also g:iced_enable_enhanced_definition_extraction.

  Key is mapped to <Plug>(iced_source_show).

 

@                                                         :IcedSourcePopupShow

:IcedSourcePopupShow [{symbol}]

  Open a popup window, and show source codes for {symbol}

  If {symbol} is not passed, symbol under cursor is used.

  If popup is not supported or codes are too long to show in popup window,

  :IcedSourceShow is called.

  See also g:iced_enable_enhanced_definition_extraction.

  Key is mapped to <Plug>(iced_source_popup_show).

 

@                                                          :IcedCommandPalette

:IcedCommandPalette

  Select command from palette.

  ctrlp.vimfzf or vim-clap is required to select namespace.

  Key is mapped to <Plug>(iced_command_palette).

 

@                                                                :IcedSpecForm

:IcedSpecForm [{keyword}]

  Open a window, and show the form of the spec.

  If {keyword} is not passed, keyword under cursor is used.

  Key is mapped to <Plug>(iced_spec_form).

 

@                                                             :IcedSpecExample

:IcedSpecExample [{keyword}]

  Open a window, and show the example of the spec.

  If {keyword} is not passed, keyword under cursor is used.

  Key is mapped to <Plug>(iced_spec_example).

 

@                                                         :IcedClojureDocsOpen

:IcedClojureDocsOpen [{symbol}]

  Open a window, and show documents for {symbol} in ClojureDocs.

  If {symbol} is not passed, symbol under cursor is used.

 

  A cache file will be created at the following path.

  - macOS  : $HOME/Library/Caches/orchard/clojuredocs/export.edn

  - Windows: FOLDERID_LocalAppData\\cache\orchard\clojuredocs\export.edn

  - Others : $XDG_CACHE_HOME or $HOME/.cache/orchard/clojuredocs/export.edn

 

  See also:

  - g:iced#clojuredocs#export_edn_url

  - g:iced#clojuredocs#use_clj_docs_on_cljs

 

  Key is mapped to <Plug>(iced_clojuredocs_open).

 

@                                                      :IcedClojureDocsRefresh

:IcedClojureDocsRefresh

  Clean a ClojureDocs cache file, and reload documents.

  See also g:iced#clojuredocs#export_edn_url.

  Key is mapped to <Plug>(iced_clojuredocs_refresh).

 

@                                                                   :IcedSlurp

:IcedSlurp

  Slurp next element.

  If no elements in current form, search next form and slurp.

  For searching next form, g:iced#paredit#slurp_max_depth is used.

  Key is mapped to <Plug>(iced_slurp).

 

@                                                                    :IcedBarf

:IcedBarf

  Barf last element in current form.

  Key is mapped to <Plug>(iced_barf).

 

@                                                                  :IcedFormat

:IcedFormat

  Reformat current form.

  Key is mapped to <Plug>(iced_format).

 

@                                                               :IcedFormatAll

:IcedFormatAll

  Reformat current buffer.

  Key is mapped to <Plug>(iced_format_all).

 

@                                                         :IcedCycleSrcAndTest

:IcedCycleSrcAndTest

  Switch between source file and test file.

  If the file does not exist, make sure you open a file with a pseudo path.

  Key is mapped to <Plug>(iced_cycle_src_and_test).

 

@                                                                    :IcedGrep

:IcedGrep [{keyword}]

  Execute g:iced#grep#prg command asynchronously.

  If {keyword} is not passed, keyword under cursor is used.

 

  NOTE: This command will change the current directory globally.

 

  Configurable option are g:iced#grep#prg and g:iced#grep#format.

  Key is mapped to <Plug>(iced_grep).

 

@                                                  :IcedBrowseRelatedNamespace

:IcedBrowseRelatedNamespace

  Browse namespaces relating to current namespace, and open selected one.

  ctrlp.vimfzf or vim-clap is required to select namespace.

  Configurable option is g:iced#related_ns#tail_patterns.

  Key is mapped to <Plug>(iced_browse_related_namespace).

 

@                                                              :IcedBrowseSpec

:IcedBrowseSpec

  Browse specs, and show spec form in document buffer.

  ctrlp.vimfzf or vim-clap is required to select spec.

  Key is mapped to <Plug>(iced_browse_spec).

 

@                                                   :IcedBrowseTestUnderCursor

:IcedBrowseTestUnderCursor

  Browse test vars, and jump to the selected var definition.

  ctrlp.vimfzf or vim-clap is required to select a test var.

  Key is mapped to <Plug>(iced_browse_test_under_cursor).

 

@                                                            :IcedClearNsCache

:IcedClearNsCache

  Clear all caches related to namespace.

 

  vim-iced will cache followings currently:

  - Existing all namespace aliases

 

  Key is mapped to <Plug>(iced_clear_ns_cache).

 

@                                                         :IcedClearCtrlpCache

:IcedClearCtrlpCache

  Clear ctrlp cache used by vim-iced.

  ctrlp.vim is required.

  Key is mapped to <Plug>(iced_clear_ctrlp_cache).

 

@                                                                 :IcedCleanNs

:IcedCleanNs

  Cleanup ns form.

  See https://github.com/clojure-emacs/refactor-nrepl#clean-ns

  Key is mapped to <Plug>(iced_clean_ns).

 

@                                                                :IcedCleanAll

:IcedCleanAll

  Cleanup buffer and ns form.

  Concretely :IcedCleanNs and :IcedFormatAll are executed.

  Key is mapped to <Plug>(iced_clean_all).

 

@                                                              :IcedAddMissing

:IcedAddMissing [{symbol}]

  Add missing libspec.

  If {symbol} is not passed, symbol under cursor is used.

 

  Namespaces and its aliases are cached for performance.

  :IcedClearNsCache will clear this cache.

 

@                                                                   :IcedAddNs

:IcedAddNs [{ns}]

  Add require to ns form.

  If {ns} is not passed, select namespaces in your project

  via ctrlp.vimfzf or vim-clap interface.

 

  Namespaces and its aliases are cached for performance.

  :IcedClearNsCache will clear this cache.

 

@                                                             :IcedThreadFirst

:IcedThreadFirst

  Convert current outer form to use -> threading macro.

  E.g.

  ;; before
  (foo (bar (baz "hello")))
  ;; after
  (-> "hello" baz bar foo)

@                                                              :IcedThreadLast

:IcedThreadLast

  Convert current outer form to use ->> threading macro.

  E.g.

  ;; before
  (foo yy (bar xx "hello"))
  ;; after
  (->> "hello" (bar xx) (foo yy))

@                                                         :IcedExtractFunction

:IcedExtractFunction

  Extract the form under cursor as a function.

 

@                                                                :IcedAddArity

:IcedAddArity

  Add an arity to defnfndefmacro, or defmethod.

 

@                                                               :IcedMoveToLet

:IcedMoveToLet

  Move the form under cursor to nearest let binding.

  If there is no let form in current top list,

  wrap the form with let.

 

@                                                            :IcedBrowseTapped

:IcedBrowseTapped [{keys}]

 

  If {keys} are not passed, select one of tapped values, and start browsing.

  ctrlp.vimfzf or vim-clap is required to select tapped values.

 

  If {keys} are passed, dig into tapped values.

  For example, when there are following tapped values:

    1st tapped value: {:foo [{:bar "baz"}]}

    2nd tapped value: {:hello "world"}

  The key to browse "baz" is 0 :foo 0 :bar .

  (The first 0 means "browse 1st tapped value")

 

  Key is mapped to <Plug>(iced_browse_tapped).

 

@                                                             :IcedClearTapped

:IcedClearTapped

  Clear all tapped values.

  Key is mapped to <Plug>(iced_clear_tapped).

 

 

@                                                  :IcedToggleWarnOnReflection

:IcedToggleWarnOnReflection

  Toggle *warn-on-reflection* in current project.

  Key is mapped to <Plug>(iced_toggle_warn_on_reflection).

 

@                                                          :IcedToggleTraceVar

:IcedToggleTraceVar [{symbol}]

  Toggle tracing {symbol} in current namespace.

  If {symbol} is not passed, symbol under cursor is used.

  Key is mapped to <Plug>(iced_toggle_trace_var).

 

@                                                           :IcedToggleTraceNs

:IcedToggleTraceNs [{ns}]

  Toggle tracing {ns}.

  If {ns} is not passed, current buffer's ns name is used.

  Key is mapped to <Plug>(iced_toggle_trace_ns).

 

@                                                                :IcedInInitNs

:IcedInInitNs

  Sets *ns* to the session's initnal namespace name.

  Key is mapped to <Plug>(iced_in_init_ns).

 

@                                                          :IcedJumpToNextSign

:IcedJumpToNextSign

  Jump cursor to next sign in current buffer.

  If search hit BOTTOM and 'wrapscan' is enabled,

  searching sign continues at TOP.

  Key is mapped to <Plug>(iced_jump_to_next_sign).

 

@                                                          :IcedJumpToPrevSign

:IcedJumpToPrevSign

  Jump cursor to previous sign in current buffer.

  If search hit TOP and 'wrapscan' is enabled,

  searching sign continues at BOTTOM.

  Key is mapped to <Plug>(iced_jump_to_prev_sign).

 

@                                                               :IcedJumpToLet

:IcedJumpToLet

  Jump cursor to nearest let form.

  If let form is not found in current top list, cursor is not moved.

  Key is mapped to <Plug>(iced_jump_to_let).

 

@                                                         :IcedStartSideloader

:IcedStartSideloader

  Start side-loading.

  Key is mapped to <Plug>(iced_start_sideloader).

  See also vim-iced-sideloader.

 

@                                                          :IcedStopSideloader

:IcedStopSideloader

  Stop side-loading.

  NOTE: nREPL does not provide the way to stop sideloader officially.

        But sideloader is a session specific mode, so we can stop

        sideloading by stopping to use current session.

 

  Key is mapped to <Plug>(iced_start_sideloader).

  See also vim-iced-sideloader.

 

------------------------------------------------------------------------------

@FUNCTIONS                                                  vim-iced-functions

 

@                                                                iced#status()

iced#status()

  Return vim-iced's status.

  This is useful to show status in status line.

 

  E.g. working with https://github.com/itchyny/lightline.vim

  let g:lightline = {
      \ 'active': {'right': [['iced']]},
      \ 'component_function': {'iced': 'iced#status'},
      \ }

 

------------------------------------------------------------------------------

@KEY MAPPINGS                                            vim-iced-key-mappings

 

@                                                         <Plug>(iced_connect)

<Plug>(iced_connect)

  Same as :IcedConnect.

 

@                                                      <Plug>(iced_disconnect)

<Plug>(iced_disconnect)

  Same as :IcedDisconnect.

 

@                                                       <Plug>(iced_reconnect)

<Plug>(iced_reconnect)

  Same as :IcedReconnect.

 

@                                                       <Plug>(iced_interrupt)

<Plug>(iced_interrupt)

  Same as :IcedInterrupt.

 

@                                                         <Plug>(iced_jack_in)

<Plug>(iced_jack_in)

  Same as :IcedJackIn.

 

@                                                 <Plug>(iced_instant_connect)

<Plug>(iced_instant_connect)

  Same as :IcedInstantConnect.

 

@                                                 <Plug>(iced_start_cljs_repl)

<Plug>(iced_start_cljs_repl)

  Same as :IcedStartCljsRepl.

 

@                                                  <Plug>(iced_quit_cljs_repl)

<Plug>(iced_quit_cljs_repl)

  Same as :IcedQuitCljsRepl.

 

@                                                            <Plug>(iced_eval)

<Plug>(iced_eval)

  Evaluate codes.

  Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval)<Plug>(sexp_outer_top_list)``

@                                                  <Plug>(iced_eval_and_print)

<Plug>(iced_eval_and_print)

  Evaluate code and print result to stdout buffer.

  Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_print)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_print)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_print)<Plug>(sexp_outer_top_list)``

@                                                    <Plug>(iced_eval_and_tap)

<Plug>(iced_eval_and_tap)

  Evaluate code and tap result by clojure.core/tap>.

  Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_tap)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_tap)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_tap)<Plug>(sexp_outer_top_list)``

@                                                <Plug>(iced_eval_and_replace)

<Plug>(iced_eval_and_replace)

  Evaluate code and replace it by the evaluation result.

  Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_replace)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_replace)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_replace)<Plug>(sexp_outer_top_list)``

@                                                         <Plug>(iced_eval_ns)

<Plug>(iced_eval_ns)

  Same as :IcedEvalNs.

 

@                                                     <Plug>(iced_eval_visual)

<Plug>(iced_eval_visual)

  Same as :IcedEvalVisual.

  This is mapped to vnoremap.

 

@                                                     <Plug>(iced_macroexpand)

<Plug>(iced_macroexpand)

  Evaluate {macroexpand}, and show result in a window.

  <Plug>(iced_macroexpand)<Plug>(sexp_outer_list)``

 

@                                                   <Plug>(iced_macroexpand_1)

<Plug>(iced_macroexpand_1)

  Evaluate {macroexpand-1}, and show result in a window.

  <Plug>(iced_macroexpand_1)<Plug>(sexp_outer_list)``

 

@                                                         <Plug>(iced_require)

<Plug>(iced_require)

  Same as :IcedRequire.

 

@                                                     <Plug>(iced_require_all)

<Plug>(iced_require_all)

  Same as :IcedRequireAll.

 

@                                                           <Plug>(iced_undef)

<Plug>(iced_undef)

  Same as :IcedUndef.

 

@                                                 <Plug>(iced_undef_all_in_ns)

<Plug>(iced_undef_all_in_ns)

  Same as :IcedUndefAllInNs.

 

@                                             <Plug>(iced_eval_outer_top_list)

<Plug>(iced_eval_outer_top_list)

  Same as :IcedEvalOuterTopList.

 

@                                                    <Plug>(iced_eval_at_mark)

<Plug>(iced_eval_at_mark)

  Same as :IcedEvalAtMark.

 

@                                        <Plug>(iced_eval_last_outer_top_list)

<Plug>(iced_eval_last_outer_top_list)

  Same as :IcedEvalLastOuterTopList.

 

@                                                      <Plug>(iced_print_last)

<Plug>(iced_print_last)

  Same as :IcedPrintLast.

 

@                                          <Plug>(iced_macroexpand_outer_list)

<Plug>(iced_macroexpand_outer_list)

  Same as :IcedMacroExpandOuterList.

 

@                                        <Plug>(iced_macroexpand_1_outer_list)

<Plug>(iced_macroexpand_1_outer_list)

  Same as :IcedMacroExpand1OuterList.

 

@                                                         <Plug>(iced_test_ns)

<Plug>(iced_test_ns)

  Same as :IcedTestNs.

 

@                                                        <Plug>(iced_test_all)

<Plug>(iced_test_all)

  Same as :IcedTestAll.

 

@                                                       <Plug>(iced_test_redo)

<Plug>(iced_test_redo)

  Same as :IcedTestRedo.

 

@                                               <Plug>(iced_test_under_cursor)

<Plug>(iced_test_under_cursor)

  Same as :IcedTestUnderCursor.

 

@                                                 <Plug>(iced_test_rerun_last)

<Plug>(iced_test_rerun_last)

  Same as :IcedTestRerunLast.

 

@                                                 <Plug>(iced_test_spec_check)

<Plug>(iced_test_spec_check)

  Same as :IcedTestSpecCheck.

 

@                                                <Plug>(iced_test_buffer_open)

<Plug>(iced_test_buffer_open)

  Same as :IcedTestBufferOpen.

 

@                                              <Plug>(iced_stdout_buffer_open)

<Plug>(iced_stdout_buffer_open)

  Same as :IcedStdoutBufferOpen.

 

@                                             <Plug>(iced_stdout_buffer_clear)

<Plug>(iced_stdout_buffer_clear)

  Same as :IcedStdoutBufferClear.

 

@                                             <Plug>(iced_stdout_buffer_close)

<Plug>(iced_stdout_buffer_close)

  Same as :IcedStdoutBufferClose.

 

@                                                        <Plug>(iced_def_jump)

<Plug>(iced_def_jump)

  Same as :IcedDefJump.

 

@                                                         <Plug>(iced_open_ns)

<Plug>(iced_open_ns)

  Same as :IcedOpenNs.

 

@                                               <Plug>(iced_browse_references)

<Plug>(iced_browse_references)

  Same as :IcedBrowseReferences.

 

@                                             <Plug>(iced_browse_dependencies)

<Plug>(iced_browse_dependencies)

  Same as :IcedBrowseDependencies.

 

@                                           <Plug>(iced_browse_var_references)

<Plug>(iced_browse_var_references)

  Same as :IcedBrowseVarReferences.

 

@                                         <Plug>(iced_browse_var_dependencies)

<Plug>(iced_browse_var_dependencies)

  Same as :IcedBrowseVarDependencies.

 

@                                                   <Plug>(iced_document_open)

<Plug>(iced_document_open)

  Same as :IcedDocumentOpen.

 

@                                             <Plug>(iced_document_popup_open)

<Plug>(iced_document_popup_open)

  Same as :IcedDocumentPopupOpen.

  Configurable options are:

  - g:iced_enable_popup_document

 

@                                                   <Plug>(iced_form_document)

<Plug>(iced_form_document)

  Same as :IcedFormDocument.

  This is convenient to display documents about the form you are editing.

 

  Configurable options are:

  - g:iced_enable_auto_document

  - g:iced_enable_popup_document

 

@                                                   <Plug>(iced_use_case_open)

<Plug>(iced_use_case_open)

  Same as :IcedUseCaseOpen.

 

@                                                   <Plug>(iced_next_use_case)

<Plug>(iced_next_use_case)

  Same as :IcedNextUseCase.

 

@                                                   <Plug>(iced_prev_use_case)

<Plug>(iced_prev_use_case)

  Same as :IcedPrevUseCase.

 

@                                                  <Plug>(iced_document_close)

<Plug>(iced_document_close)

  Same as :IcedDocumentClose.

 

@                                                     <Plug>(iced_source_show)

<Plug>(iced_source_show)

  Same as :IcedSourceShow.

 

@                                               <Plug>(iced_source_popup_show)

<Plug>(iced_source_popup_show)

  Same as :IcedSourcePopupShow.

 

@                                                 <Plug>(iced_command_palette)

<Plug>(iced_command_palette)

  Same as :IcedCommandPalette.

 

@                                                       <Plug>(iced_spec_form)

<Plug>(iced_spec_form)

  Same as :IcedSpecForm.

 

@                                                    <Plug>(iced_spec_example)

<Plug>(iced_spec_example)

  Same as :IcedSpecExample.

 

@                                                <Plug>(iced_clojuredocs_open)

<Plug>(iced_clojuredocs_open)

  Same as :IcedClojureDocsOpen.

 

@                                             <Plug>(iced_clojuredocs_refresh)

<Plug>(iced_clojuredocs_refresh)

  Same as :IcedClojureDocsRefresh.

 

@                                                           <Plug>(iced_slurp)

<Plug>(iced_slurp)

  Same as :IcedSlurp.

 

@                                                            <Plug>(iced_barf)

<Plug>(iced_barf)

  Same as :IcedBarf.

 

@                                                          <Plug>(iced_format)

<Plug>(iced_format)

  Same as :IcedFormat.

 

@                                                      <Plug>(iced_format_all)

<Plug>(iced_format_all)

  Same as :IcedFormatAll.

 

@                                              <Plug>(iced_cycle_src_and_test)

<Plug>(iced_cycle_src_and_test)

  Same as :IcedCycleSrcAndTest.

 

@                                                            <Plug>(iced_grep)

<Plug>(iced_grep)

  Same as :IcedGrep.

 

@                                        <Plug>(iced_browse_related_namespace)

<Plug>(iced_browse_related_namespace)

  Same as :IcedBrowseRelatedNamespace.

 

@                                                     <Plug>(iced_browse_spec)

<Plug>(iced_browse_spec)

  Same as :IcedBrowseSpec.

 

@                                        <Plug>(iced_browse_test_under_cursor)

<Plug>(iced_browse_test_under_cursor)

  Same as :IcedBrowseTestUnderCursor.

 

@                                                  <Plug>(iced_clear_ns_cache)

<Plug>(iced_clear_ns_cache)

  Same as :IcedClearNsCache.

 

@                                               <Plug>(iced_clear_ctrlp_cache)

<Plug>(iced_clear_ctrlp_cache)

  Same as :IcedClearCtrlpCache.

 

@                                                        <Plug>(iced_clean_ns)

<Plug>(iced_clean_ns)

  Same as :IcedCleanNs.

 

@                                                       <Plug>(iced_clean_all)

<Plug>(iced_clean_all)

  Same as :IcedCleanAll.

 

@                                                     <Plug>(iced_add_missing)

<Plug>(iced_add_missing)

  Same as :IcedAddMissing.

 

@                                                          <Plug>(iced_add_ns)

<Plug>(iced_add_ns)

  Same as :IcedAddNs.

 

@                                                    <Plug>(iced_thread_first)

<Plug>(iced_thread_first)

  Same as :IcedThreadFirst.

 

@                                                     <Plug>(iced_thread_last)

<Plug>(iced_thread_last)

  Same as :IcedThreadLast.

 

@                                                <Plug>(iced_extract_function)

<Plug>(iced_extract_function)

  Same as :IcedExtractFunction.

 

@                                                       <Plug>(iced_add_arity)

<Plug>(iced_add_arity)

  Same as :IcedAddArity.

 

@                                                     <Plug>(iced_move_to_let)

<Plug>(iced_move_to_let)

  Same as :IcedMoveToLet.

 

@                                                   <Plug>(iced_browse_tapped)

<Plug>(iced_browse_tapped)

  Same as :IcedBrowseTapped.

 

@                                                    <Plug>(iced_clear_tapped)

<Plug>(iced_clear_tapped)

  Same as :IcedClearTapped.

 

@                                                <Plug>(iced_toggle_trace_var)

<Plug>(iced_toggle_trace_var)

  Same as :IcedToggleTraceVar.

 

@                                                 <Plug>(iced_toggle_trace_ns)

<Plug>(iced_toggle_trace_ns)

  Same as :IcedToggleTraceNs.

 

@                                                      <Plug>(iced_in_init_ns)

<Plug>(iced_in_init_ns)

  Same as :IcedInInitNs.

 

@                                               <Plug>(iced_jump_to_next_sign)

<Plug>(iced_jump_to_next_sign)

  Same as :IcedJumpToNextSign.

 

@                                               <Plug>(iced_jump_to_prev_sign)

<Plug>(iced_jump_to_prev_sign)

  Same as :IcedJumpToPrevSign.

 

@                                                     <Plug>(iced_jump_to_let)

<Plug>(iced_jump_to_let)

  Same as :IcedJumpToLet.

 

@                                                <Plug>(iced_start_sideloader)

<Plug>(iced_start_sideloader)

  Same as :IcedStartSideloader.

 

@                                                 <Plug>(iced_stop_sideloader)

<Plug>(iced_stop_sideloader)

  Same as :IcedStopSideloader.

 

==============================================================================

@CUSTOMIZING                                              vim-iced-customizing

 

@                                                            g:iced#nrepl#host

g:iced#nrepl#host

  Connection host name.

  Default value is '127.0.0.1'.

 

@                                                     g:iced#nrepl#buffer_size

g:iced#nrepl#buffer_size

  Threshold for nREPL response length.

  If response exceed this threshold, vim-iced will handle the response as

  too large response and warn.

  Default value is 1048576.

 

@                    g:iced#nrepl#skip_evaluation_when_buffer_size_is_exceeded

g:iced#nrepl#skip_evaluation_when_buffer_size_is_exceeded

  If {v:true}, skip evaluation when the nREPL response length exceed

  g:iced#nrepl#buffer_size.

  Default value is v:false.

 

@                                         g:iced#nrepl#connect#jack_in_command

g:iced#nrepl#connect#jack_in_command

  Command to start REPL in :IcedJackIn.

  Default value is 'iced repl' .

 

                                               sg:iced#paredit#slurp_max_depth

g:iced#paredit#slurp_max_depth

  Maximum depth for slurping.

  Default value is 5.

 

@                                                      g:iced#cljs#default_env

g:iced#cljs#default_env

  Environment used when :IcedStartCljsRepl is called with no argument.

  Default value is 'figwheel'.

 

@                                                   g:iced#eval#inside_comment

g:iced#eval#inside_comment

  If {v:true}, evaluate inside comment form.

  Default value is v:true.

  See https://liquidz.github.io/vim-iced/#configuration_evaluation

 

@                                                     g:iced#eval#mark_at_last

g:iced#eval#mark_at_last

  The mark to set last evaluated position.

  It is recommended to use the mark which can be used by globally.

  Default value is 1.

 

@                                                   g:iced#buffer#error#height

g:iced#buffer#error#height

  Error window height.

  Default value is 'previewheight'.

 

@                                                g:iced#debug#value_max_length

g:iced#debug#value_max_length

  Max length to show value in debugging.

  Negative value means no limitation.

  Default value is -1.

 

@                                                    g:iced#promise#timeout_ms

g:iced#promise#timeout_ms

  Timeout time for waiting promises.

  Unit is milli sec.

  Default value is 3000.

 

@                                              g:iced#related_ns#tail_patterns

g:iced#related_ns#tail_patterns

  The namespace tailing pattern to decide the namespace is related or not.

  This option is used by:IcedBrowseRelatedNamespace command.

  Default value is ['', '-test', '-spec', '\.spec'] .

 

@                                                   g:iced#test#spec_num_tests

g:iced#test#spec_num_tests

  Default num-tests for :IcedTestSpecCheck.

  Default value is 10.

 

@                                                             g:iced#qf#height

g:iced#qf#height

  Quickfix window height.

  Default value is 5.

 

@                                                              g:iced#grep#prg

g:iced#grep#prg

  Program to use for the :IcedGrep command.

  Format is same as 'grepprg'.

  Default value is 'git grep --no-index -I --line-number --no-color' .

 

@                                                           g:iced#grep#format

g:iced#grep#format

  Format to recognize for the :IcedGrep command output.

  Format is same as 'grepformat'.

  Default value is '%f:%l:%m,%f:%l%m,%f %l%m' .

 

@                                             g:iced#refactor#prefix_rewriting

g:iced#refactor#prefix_rewriting

  Should clean-ns favor prefix forms in the ns macro?

  c.f. https://github.com/clojure-emacs/refactor-nrepl#available-features

  Default value is v:false.

 

@                                        g:iced#nrepl#auto#does_switch_session

g:iced#nrepl#auto#does_switch_session

  If {v:true}, enable automatic switching CLJ/CLJS session.

  This will be done by WinEnter auto command.

  Default value is v:false.

 

@                                         g:iced#nrepl#complete#ignore_context

g:iced#nrepl#complete#ignore_context

  If {v:true}, the manipulation for completion ignores collecting contexts.

  This means that results no longer includes information in contexts.

  Enable this option only when you have a trouble with performance.

  Default value is v:false.

 

@                                       g:iced_enable_enhanced_cljs_completion

g:iced_enable_enhanced_cljs_completion

  If {v:true}, enable enhanced ClojureScript completion.

  Default value is v:true.

 

@                                                          g:iced#clap#options

g:iced#clap#options

  Options for starting vim-clap selector.

  E.g. using fzf as an external filter: ['++externalfilter=fzf', '+async']

  Default value is [].

 

@                                                g:iced#nrepl#path_translation

g:iced#nrepl#path_translation

  Path translation rule dictionary.

  It is useful when connecting to nREPL in docker container.

  E.g.

    let g:iced#nrepl#path_translation = {
          \ '/root': $HOME,
          \ }

  Default value is {}.

  See also vim-iced-install-docker.

 

@                                 g:iced_enable_enhanced_definition_extraction

g:iced_enable_enhanced_definition_extraction

  If {v:true}, enable enhanced source extraction.

  This feature will extract source by let form also.

  Default value is v:true.

  See also g:iced#nrepl#source#finding_max_depth.

 

  WARNING:

    Enhanced source extraction requires borkdude/jet.

    https://github.com/borkdude/jet

    vim-iced will confirm you to install jet automatically If not installed.

 

@                                        g:iced#nrepl#source#finding_max_depth

g:iced#nrepl#source#finding_max_depth

  Max depth for finding source.

  This value is used on enhanced source extraction.

  Default value is 3.

  See also g:iced_enable_enhanced_definition_extraction.

  

@                                               g:iced#repl#babashka_repl_type

g:iced#repl#babashka_repl_type

  REPL type of server launching by babashka.

  'socket' or 'nrepl' can be set.

  Default value is 'socket'.

 

------------------------------------------------------------------------------

@STDOUT BUFFER                              vim-iced-customizing-stdout-buffer

 

@                                                    g:iced#buffer#stdout#mods

g:iced#buffer#stdout#mods

  Buffer position definition.

  Following values are supported.

  - {vertical}

  - {leftabove}

  - {aboveleft}

  - {rightbelow}

  - {belowright}

  - {topleft}

  - {botright}

 

@                                                    g:iced#buffer#stdout#file

g:iced#buffer#stdout#file

  If not empty, vim-iced write stdout buffer content to the file path.

  Default value is ''.

  See also g:iced#buffer#stdout#file_buffer_size.

 

@                                        g:iced#buffer#stdout#file_buffer_size

g:iced#buffer#stdout#file_buffer_size

  Max line count to buffer for g:iced#buffer#stdout#file.

  Default value is 256.

 

@                                                g:iced#buffer#stdout#max_line

g:iced#buffer#stdout#max_line

  Max line count to keep in stdout buffer.

  If negative number is setted, it means no limit.

  Default value is -1.

 

@                                     g:iced#buffer#stdout#deleting_line_delay

g:iced#buffer#stdout#deleting_line_delay

  Delay time for deleting excess lines in stdout buffer.

  Unit is milli sec.

  This option is enabled when g:iced#buffer#stdout#max_line is a positive

  number.

  Default value is 1000.

 

------------------------------------------------------------------------------

@FORMATTER                                      vim-iced-customizing-formatter

 

@                                                             g:iced_formatter

g:iced_formatter

  Formatter name.

  Following formatters can be used.

 

  - default

    Default formatter powered by cljfmt.

  - cljstyle

    https://github.com/greglook/cljstyle

    If cljstyle is not installed, will install automatically.

  - zprint

    https://github.com/kkinnear/zprint

    If zprint is not installed, will install automatically.

  - joker

    https://github.com/candid82/joker

    If joker is not installed, will install automatically.

 

------------------------------------------------------------------------------

@INDENT RULES                                     vim-iced-customizing-indents

 

@                                                           g:iced#format#rule

g:iced#format#rule

  Cljfmt's formatting rule.

  See https://github.com/weavejester/cljfmt#indentation-rules

  let g:iced#format#rule = {
        \ 'merr.core/let': '[[:block 2] [:inner 1]]',
        \ }

@                                             vim-iced-customizing-tonsky-rule

TONSKY'S RULE

  See http://tonsky.me/blog/clojurefmt/ .

  You can use this rule with cljfmt and cljstyle.

 

  - cljfmt

    let g:iced#format#rule = {'#"^\w"': '[[:inner 0]]'}

  - cljstyle

    Add following :indents setting to your .cljstyle.

    {
     :indents ^:replace {#"^\w" [[:inner 0]]}
     }

------------------------------------------------------------------------------

@DOCUMENTS                                      vim-iced-customizing-documents

 

@                                                g:iced#buffer#document#height

g:iced#buffer#document#height

  Document window height.

  Default value is 'previewheight'.

 

@                             g:iced#buffer#document#does_update_automatically

g:iced#buffer#document#does_update_automatically

  If {v:true} and document buffer is visible,

  update document buffer with document for the form under cursor.

  Default value is v:false.

 

@                                            g:iced#clojuredocs#export_edn_url

g:iced#clojuredocs#export_edn_url

  The URL exported from ClojureDocs.

  EDN format file is expected.

  Default value is https://clojuredocs-edn.netlify.com/export.edn.

 

@                                      g:iced#clojuredocs#use_clj_docs_on_cljs

g:iced#clojuredocs#use_clj_docs_on_cljs

  If {v:true}, use Clojure documents instead of ClojureScript.

  Default value is v:false.

  See also g:iced#clojuredocs#cljs_ns_replace_map.

 

@                                       g:iced#clojuredocs#cljs_ns_replace_map

g:iced#clojuredocs#cljs_ns_replace_map

  The namespace conversion table for g:iced#clojuredocs#use_clj_docs_on_cljs

  option.

  Default value is {'cljs.core': 'clojure.core'} .

 

@                                           vim-iced-customizing-auto-document

AUTO DOCUMENT

 

@                                                  g:iced_enable_auto_document

g:iced_enable_auto_document

  Enable automatic displaying one-line document.

  This will be done by CursorHold and CursorHoldI auto command.

 

  The value should be one of 'normal''insert' or 'any'.

  Otherwise, this option will be disabled.

 

  'normal': Enabled on only normal mode.

  'insert': Enabled on only insert mode.

  'every' : Enabled on normal and insert mode.

 

  Default value is 'none'.

  See also g:iced_enable_popup_document.

 

@                                                 g:iced_enable_popup_document

g:iced_enable_popup_document

  Display documents on popup window.

  The value should be one of follows.

  Otherwise, this option will be disabled.

 

  'full'    : Enabled on only full document.

              :IcedDocumentOpen shows full document.

  'one-line': Enabled on only one-line document.

  'every'   : Every enabled.

 

  Default value is 'every'.

 

@                                        g:iced_max_distance_for_auto_document

g:iced_max_distance_for_auto_document

  Max line distance to display one-line document.

  See also g:iced_enable_auto_document.

 

  Default value is 2.

 

------------------------------------------------------------------------------

@AUTO INDENT                                  vim-iced-customizing-auto-indent

 

@                                                    g:iced_enable_auto_indent

g:iced_enable_auto_indent

  If {v:true}, enable indenting automatically.

  Default value is v:true.

  See details: vim-iced-indenting.

 

------------------------------------------------------------------------------

@SIGNS                                              vim-iced-customizing-signs

 

@                                                                  g:iced_sign

g:iced_sign

  Sign setting.

  vim-iced provides following signs.

  - iced_error (for test failure position)

  - iced_trace (for tracing var position)

 

  Each sign has default setting as follows.

  {
    'error':   '🔥',
    'trace':   '👁',
    'errorhl': 'ErrorMsg',
    'tracehl': 'Search',
  }

  You can change the setting by g:iced_sign variable.

  E.g. changing sign text

  let g:iced_sign = {'error': 'E', 'trace': 'T'}

------------------------------------------------------------------------------

@COMMAND PALETTES                                 vim-iced-customizing-palette

 

@                                                               g:iced#palette

g:iced#palette

  User custom commands.

  E.g. define command palette to start cljs REPL

  let g:iced#palette = {
        \ 'foo bar': ':IcedEvalRepl (cljs-repl)'
        \ }

------------------------------------------------------------------------------

@HOOKS                                              vim-iced-customizing-hooks

 

@                                                                  g:iced#hook

g:iced#hook

  Hook setting.

 

  - Hook kinds

    - connected         hook_kind_connected

    - disconnected      hook_kind_disconnected

    - test_finished     hook_kind_test_finished

    - ns_required       hook_kind_ns_required

    - ns_all_reloaded   hook_kind_ns_all_reloaded

    - session_switched  hook_kind_session_switched

  - Hook report types

    - shell             hook_report_shell

    - eval              hook_report_eval

    - function          hook_report_function

    - command           hook_report_command

 

  E.g.

  let g:iced#hook = {
      \ 'test_finished':
      \ {'type': 'shell',
      \  'exec': {v -> printf('tmux display-message "%s"', v.summary)}}
      \ }

@CONNECTED                                                 hook_kind_connected

 

  Hooked when vim-iced is connected to nREPL.

  No parameters are passed to reporter.

 

@DISCONNECTED                                           hook_kind_disconnected

 

  Hooked when vim-iced is disconnected from nREPL.

  No parameters are passed to reporter.

 

@TEST FINISHED                                         hook_kind_test_finished

 

  Hooked when running test is finished.

  Following parameters are pass to reporter.

 

  - result

    Test result. "succeeded" or "failed".

  - summary

    Test summary.

 

@NS REQUIRED                                             hook_kind_ns_required

 

  Hooked when :IcedRequire is finished.

 

@NS ALL RELOADED                                     hook_kind_ns_all_reloaded

 

  Hooked when :IcedRequireAll is finished.

 

@SESSION SWITCHED                                   hook_kind_session_switched

 

  Hooked when current session is switched.

  Following parameters are pass to reporter.

 

  - session

    Destination session type. "clj" or "cljs".

 

------------------------------------------------------------------------------

@POPUP WINDOW                                vim-iced-customizing-popup-window

 

@                                                            g:iced#popup#time

g:iced#popup#time

  Auto closing time(ms) for popup window.

  Default value is 3000.

 

@                                                      g:iced#popup#max_height

g:iced#popup#max_height

  Max height for popup window.

  Default value is 50.

 

@                                             g:iced#popup#neovim#winhighlight

g:iced#popup#neovim#winhighlight

  winhighlight option for floating window in Neovim.

  - https://neovim.io/doc/user/options.html#'winhighlight'

  Default value is 'Normal:NormalFloat'.

 

@                                                    g:iced#popup#neovim#style

g:iced#popup#neovim#style

  style option for floating window in Neovim.

  - https://neovim.io/doc/user/api.html#nvim_open_win()

  Default value is 'minimal'.

 

------------------------------------------------------------------------------

@SIDELOADER                                    vim-iced-customizing-sideloader

 

 

@                                               g:iced#nrepl#enable_sideloader

g:iced#nrepl#enable_sideloader

  If v:true, vim-iced starts sideloader on startup automatically.

  Default value is v:false.

 

@                                                          g:iced#source_root

g:iced#source_root

  If you have ghqgit config ghq.root will be the value automatically.

  - https://github.com/x-motemen/ghq

 

------------------------------------------------------------------------------

@DEFAULT KEYS                                vim-iced-customizing-default-keys

 

PREFIXES

  - <Leader>e: Evaluating

  - <Leader>t: Testing

  - <Leader>s: Stdout buffer

  - <Leader>r: Refactoring

  - <Leader>h: Help/Document

  - <Leader>b: Browsing

  - <Leader>j: Jumping cursor

 

@                                            g:iced_default_key_mapping_leader

g:iced_default_key_mapping_leader

  <Leader> key for default key mappings.

 

  If you'd like to use <LocalLeader> instead of <Leader>,

  please set as follows:

  let g:iced_default_key_mapping_leader = '<LocalLeader>'

  Default value is '<Leader>'.

 

@                                           g:iced_enable_default_key_mappings

g:iced_enable_default_key_mappings

  If {v:true}, apply following mappings.

 

  {mode}  {lhs}        {rhs}

  ------  -----------  ---------------------------------------------------

  n       <Leader>'    <Plug>(iced_connect)

  n       <Leader>"    <Plug>(iced_jack_in)

  n       <Leader>ei   <Plug>(iced_eval)<Plug>(sexp_inner_element)``

  n       <Leader>ee   <Plug>(iced_eval)<Plug>(sexp_outer_list)``

  n       <Leader>et   <Plug>(iced_eval_outer_top_list)

  n       <Leader>ea   <Plug>(iced_eval_at_mark)

  n       <Leader>el   <Plug>(iced_eval_last_outer_top_list)

  n       <Leader>en   <Plug>(iced_eval_ns)

  v       <Leader>ee   <Plug>(iced_eval_visual)

  n       <Leader>ep   <Plug>(iced_print_last)

  n       <Leader>eb   <Plug>(iced_require)

  n       <Leader>eB   <Plug>(iced_require_all)

  n       <Leader>eu   <Plug>(iced_undef)

  n       <Leader>eU   <Plug>(iced_undef_all_in_ns)

  n       <Leader>eq   <Plug>(iced_interrupt)

  n       <Leader>eQ   <Plug>(iced_interrupt_all)

  n       <Leader>eM   <Plug>(iced_macroexpand_outer_list)

  n       <Leader>em   <Plug>(iced_macroexpand_1_outer_list)

  n       <Leader>tt   <Plug>(iced_test_under_cursor)

  n       <Leader>tl   <Plug>(iced_test_rerun_last)

  n       <Leader>ts   <Plug>(iced_test_spec_check)

  n       <Leader>to   <Plug>(iced_test_buffer_open)

  n       <Leader>tn   <Plug>(iced_test_ns)

  n       <Leader>tp   <Plug>(iced_test_all)

  n       <Leader>tr   <Plug>(iced_test_redo)

  n       <Leader>ss   <Plug>(iced_stdout_buffer_open)

  n       <Leader>sl   <Plug>(iced_stdout_buffer_clear)

  n       <Leader>sq   <Plug>(iced_stdout_buffer_close)

  n       <Leader>rcn  <Plug>(iced_clean_ns)

  n       <Leader>rca  <Plug>(iced_clean_all)

  n       <Leader>raa  <Plug>(iced_add_arity)

  n       <Leader>ram  <Plug>(iced_add_missing)

  n       <Leader>ran  <Plug>(iced_add_ns)

  n       <Leader>rtf  <Plug>(iced_thread_first)

  n       <Leader>rtl  <Plug>(iced_thread_last)

  n       <Leader>ref  <Plug>(iced_extract_function)

  n       <Leader>rml  <Plug>(iced_move_to_let)

  n       K            <Plug>(iced_document_popup_open)

  n       <Leader>hb   <Plug>(iced_document_open)

  n       <Leader>hu   <Plug>(iced_use_case_open)

  n       <Leader>hn   <Plug>(iced_next_use_case)

  n       <Leader>hN   <Plug>(iced_prev_use_case)

  n       <Leader>hq   <Plug>(iced_document_close)

  n       <Leader>hs   <Plug>(iced_source_popup_show)

  n       <Leader>hS   <Plug>(iced_source_show)

  n       <Leader>hc   <Plug>(iced_clojuredocs_open)

  n       <Leader>hh   <Plug>(iced_command_palette)

  n       <Leader>bn   <Plug>(iced_browse_related_namespace)

  n       <Leader>bs   <Plug>(iced_browse_spec)

  n       <Leader>bt   <Plug>(iced_browse_test_under_cursor)

  n       <Leader>br   <Plug>(iced_browse_references)

  n       <Leader>bd   <Plug>(iced_browse_dependencies)

  n       <C-]>        <Plug>(iced_def_jump)

  n       <Leader>jn   <Plug>(iced_jump_to_next_sign)

  n       <Leader>jN   <Plug>(iced_jump_to_prev_sign)

  n       <Leader>jl   <Plug>(iced_jump_to_let)

  n       <Leader>dbt  <Plug>(iced_browse_tapped)

  n       <Leader>dlt  <Plug>(iced_clear_tapped)

  n       <Leader>*    <Plug>(iced_grep)

  n       <Leader>/    :<C-u>IcedGrep<Space>

  n       ==           <Plug>(iced_format)

  n       =G           <Plug>(iced_format_all)

 

==============================================================================

@CHANGELOG                                                  vim-iced-changelog

 

See https://github.com/liquidz/vim-iced/blob/master/CHANGELOG.adoc

 

==============================================================================

vim:tw=78:ts=8:ft=help:norl:noet:fen:fdl=0: