LightTable settings backup

user.behaviors

;; User behaviors 
;; -----------------------------
;; Behaviors are stored as a set of diffs that are merged together
;; to create the final set of functionality that makes up Light Table. You can
;; modify these diffs to either add or subtract functionality.
;;
;; Behaviors are added to tags, objects with those tags then automatically gain
;; whatever logic the behavior imparts. To see a list of user-level behaviors,
;; start typing a word related to the functionality you want in between the square
;; brackets (e.g. "theme").

{:+ {
     ;; The app tag is kind of like global scope. You assign behaviors that affect
     ;; all of Light Table here
     :app [(:lt.objs.style/set-skin "dark")
           (:lt.objs.sidebar.workspace/workspace.open-on-start)]

     ;; The editor tag is applied to all editors
     :editor [:lt.objs.editor/wrap
              (:lt.objs.style/set-theme "solarized")
              (:lt.objs.editor/line-numbers)
              (:lt.objs.editor/highlight-current-line)
              (:lt.objs.style/font-settings "Consolas for Powerline" "10" "1.3")
              (:lt.objs.tabs/set-width-final! "2")
              (:lt.plugins.visible-whitespace/show-whitespace)
              (:lt.objs.editor/scroll-past-end)
              (:lt.objs.editor/fold-gutter)
              (:lt.plugins.match-highlighter/enable)
              (:lt.objs.editor.file/preserve-line-endings)
              (:lt.plugins.auto-paren/close-pair)]

     ;; Here we can add behaviors to just clojure editors
     :editor.clojure [(:lt.plugins.clojure/print-length 1000)]}

 ;; You can use the subtract key to remove behavior that may get added by
 ;; another diff 
 :- {:app []}}

user.keymap

;; User keymap
;; -----------------------------
;; Keymaps are stored as a set of diffs that are merged together to create
;; the final set of keys. You can modify these diffs to either add or
;; subtract bindings.
;;
;; Like behaviors, keys are bound by tag. When objects with those tags are active
;; the key bindings are live. Keys can be bound to any number of Light Table commands,
;; allowing you the flexibility to execute multiple operations together. To see a list
;; of all the commands you can execute, start typing a word related to the thing you
;; want to do in between the square brackets (e.g. type "editor").

{:+ {:app {"ctrl-shift-p" [:show-commandbar]
           "ctrl-shift-alt-t" [:lt.plugins.opener/open-terminal-in-active-workspace]
           "ctrl-f" [:find.show]
           "ctrl-h" [:find.replace]
           "ctrl-shift-w" [:workspace.show]
           "ctrl-x-b" [:lt.plugins.bufferize/switch-buffer]
           "ctrl-x-r" [:lt.plugins.opener/reveal-active-item]}

     :editor {"alt-w" [:editor.watch.watch-selection]
              "alt-shift-w" [:editor.watch.unwatch]
              "ctrl-x" [:editor.cut]
              "shift-tab" [:unindent-selection]
              "ctrl-/" [:toggle-comment-selection]}
              }}}