Tutkain.sublime-settings

{
  // Toggle automatic namespace switching.
  //
  // If true, before evaluating a form, Tutkain automatically switches your
  // current Clojure(Script) namespace to the namespace defined by the last ns
  // form in the current view, or the default namespace for the current dialect
  // (user for Clojure, cljs.user for ClojureScript) if none.
  "auto_switch_namespace": true,

  // The method of communication Tutkain uses when talking with the runtime it
  // is connected to.
  //
  // This setting affects the Clojure and Babashka runtimes only. ClojureScript
  // always uses the RPC mode.
  //
  // Valid options:
  //
  // - "repl": a Read-Eval-Print loop over a streaming socket connection. When
  //   in REPL mode, Tutkain uses the initial connection for evaluating code
  //   and opens a second connection to the runtime for everything else (e.g.
  //   auto-completion, clojure.test integration, etc.).
  //
  //   Use the REPL mode if you want to use nested REPLs. Use the REPL mode if
  //   support for printing large evaluation results is important to you.
  //
  // - "rpc": in the Remote Procedure Call (RPC) mode, Tutkain operates over a
  //   single connection to the runtime. In the RPC mode, every message Tutkain
  //   sends to and receives from the runtime is wrapped in an EDN envelope.
  //
  //   Use the RPC mode if you want Tutkain to operate over a single connection
  //   (e.g. when establishing more than one connection to the runtime is
  //   difficult or impossible).
  //
  //   You cannot use nested REPLs in the RPC mode.
  //
  // Note that certain evaluation outputs always use the RPC mode (e.g.
  // clipboard, inline).
  //
  // You can override this setting by specifying the connection mode as an
  // argument to the tutkain_connect command. For example:
  //
  //     {
  //         "keys": ["ctrl+c", "ctrl+x"],
  //         "command": "tutkain_connect",
  //         "args": {"mode": "rpc", ...}
  //     }
  //
  // In the REPL mode, you can also use the "mode" argument to tutkain_evaluate
  // to switch between REPL and RPC modes. For example:
  //
  //     {
  //         "keys": ["ctrl+c", "ctrl+c"],
  //         "command": "tutkain_evaluate",
  //         "args": {"mode": "rpc", ...}
  //     },
  //
  // It is possible to turn a REPL interface into an RPC interface, but not the
  // other way around. Therefore, if the connection uses the RPC mode,
  // evaluations cannot use the REPL mode.
  //
  // By default, Tutkain uses the connection mode as the evaluation mode.
  //
  // If neither nested REPLs nor having a single connection is important to
  // you, it likely does not matter much which connection mode you use.
  "default_connection_mode": "repl",

  // Enable debug logging in Sublime Text console.
  "debug": false,

  // The window layout Tutkain uses after connecting to a runtime.
  //
  // Valid options:
  // - "horizontal"
  // - "vertical"
  "layout": "horizontal",

  // Toggle var info lookup on hover.
  //
  // Disabled by default to prevent it from interfering with other packages
  // (e.g. SublimeLSP).
  "lookup_on_hover": false,

  // Toggle tap panel.
  //
  // If the tap panel is enabled, calling clojure.core/tap> will pretty-print the the function
  // argument in a Sublime Text output panel. Useful for debugging.
  "tap_panel": false,

  // Toggle auto-completion.
  //
  // If you use something like clojure-lsp, you might want to turn this off to
  // prevent Tutkain's auto-completion from interfering with clojure-lsp's
  // auto-completion.
  "auto_complete": true,

  // If true, when your caret is on top of a local (let-bound symbol, fn arg,
  // etc.), highlight instances of that local within the current context.
  //
  // Requires clojure.tools.analyzer.jvm in your classpath.
  "highlight_locals": true,

  "clojure": {
    // Backchannel settings.
    //
    // The backchannel powers features like auto-completion, var lookup,
    // clojure.test integration, etc.
    "backchannel": {
      // The TCP socket port you want the backchannel to listen on. Use port
      // number 0 to automatically allocate an available port.
      //
      // You only need to override this setting if you want to use Tutkain over
      // an SSH tunnel or if you're debugging Tutkain itself.
      //
      // NOTE: If you use a fixed port number, you can only open a single
      // connection from Tutkain to a runtime. This is because
      // Tutkain currently uses one backchannel per connection.
      "port": 0,
      // Bind address for backchannel.
      "bind_address": "localhost"
    },
  },

  "babashka": {
    // The same backchannel settings as above, but for Babashka.
    "backchannel": {
      "port": 0,
      "bind_address": "localhost"
    },
  },

  // You can overwrite Tutkain's default settings for a REPL view.
  "repl_view_settings": {},

  // When printing REPL output into a panel instead of a view, toggle whether
  // to automatically show the output panel when evaluating.
  //
  // If you mainly use inline evaluation results, you might want to set this to
  // "false".
  "auto_show_output_panel": true
}