emacs.d
文件大小: unknow
源码售价: 5 个金币 积分规则     积分充值
资源说明:
#+INFOJS_OPT: view:t toc:t ltoc:t mouse:underline buttons:0 path:https://www.linux.org.ru/tango/combined.css
#+HTML_HEAD: 
#+HTML_HEAD: 
#+PROPERTY: header-args:emacs-lisp :tangle "init.el"
* Foreword and keynotes
** Use-package
   [[https://github.com/jwiegley/use-package][Use-package]] is an Emacs configuration manager (*not* a package manager!) that allows you to keep init file(s) clean, tidy and declarative.

   - use it for built-in packages/libraries too (without ~:ensure t~)
   - each variable/face setting or each function call belongs to the one and only package which provides the symbol
   To find out, where do they belong to, use /M-x describe-variable/, /M-x describe-face/ or /M-x describe-function/ accordingly.

*** Setting variables
    "Traditional" [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Setting-Variables.html][setq]] is almost always means changing a customizable variable, so can be rewritten with [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Applying-Customizations.html][customize-set-variable]] and therefore with [[https://github.com/jwiegley/use-package#customizing-variables][:custom]] keyword, it supports inline comments. Besides that some defcustoms [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Variable-Definitions.html#Variable-Definitions][have get/set functions]] so ~setq~-ing will have no effect unless you run a setter manually .

    /At the same time I don't use [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Easy-Customization.html][Customization]] interface, and my own [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Saving-Customizations.html][custom-file]] is =/dev/null=./

    An example
    #+BEGIN_SRC emacs-lisp :tangle no
      ;; "Don't show splash screen"
      (setq inhibit-startup-screen t)
    #+END_SRC
    becomes
    #+BEGIN_SRC emacs-lisp :tangle no
      :custom
      (inhibit-startup-screen t "Don't show splash screen")
    #+END_SRC

*** Faces
    There's [[https://github.com/jwiegley/use-package#customizing-faces][:custom-face]], so
    #+BEGIN_SRC emacs-lisp :tangle no
      (set-face-attributes 'Man-overstrike nil :inherit font-lock-type-face :bold t)
    #+END_SRC
    becomes
    #+BEGIN_SRC emacs-lisp :tangle no
      :custom-face
      (Man-overstrike ((t (:inherit font-lock-type-face :bold t))))
    #+END_SRC

    Hardcoded faces can break themes, so I use [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Face-Attributes.html][:inherit]] for customizations, if possible.

*** Hooks
    [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Hooks.html][add-hook]] → [[https://github.com/jwiegley/use-package#hooks][:hook]]

*** Key-binding
    [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Changing-Key-Bindings.html][define-key]] → [[https://github.com/jwiegley/use-package#key-binding][:bind]]

*** Sequential loading
    use [[https://github.com/jwiegley/use-package#loading-packages-in-sequence][:after]] if you want to load a package after another one

*** Installing packages from source code
    There are several ways to do it, but I prefer [[https://github.com/quelpa/quelpa][Quelpa]] since it's compatible with Emacs [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Packages.html][Package manager]]

*** Definitions
    I put all defuns to separate packages/libraries to keep the config declarative

** More on key-binding
   - I try not to hardcode bindings starting with /C-x/, /C-c/ and /C-h/, which are [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Prefix-Keymaps.html#Prefix-Keymaps][bound]] to ~ctl-x-map~, ~mode-specific-map~ and ~help-map~ respectively. Not that I'm not happy with all these defaults (except /C-h/, see *simple* package below), but I want to be able to rebind them to something else (/SPC/, /mouse-1/, break, gas or whatever), at least for my own bindings — sadly, some plugins hardcode them (and that causes issues for alternative bindings users), but I hope it will change someday.

   - I use named prefix keymaps so they are visible in minibuffer while [[https://github.com/justbur/emacs-which-key][Which-key]] is active.

   - I use [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Remapping-Commands.html][remap]] if I want to rebind a command to a "better" version of it and do an explicit keys declaration when I rebind it to something completely different.

   - Where mnemonics conflicts with ergonomics - prefer the former.

* Package system
** Initialization
   By default, Emacs knows about [[https://elpa.gnu.org/][GNU ELPA]] only, add [[https://melpa.org][some]] [[https://orgmode.org/elpa.html][more]] repositories.
   #+BEGIN_SRC emacs-lisp
     ;;; -*- lexical-binding: t; -*-

     (require 'package)
     (customize-set-variable 'package-archives
                             `(("melpa" . "https://melpa.org/packages/")
                               ,@package-archives))
     (customize-set-variable 'package-enable-at-startup nil)
     (package-initialize)
   #+END_SRC
** [[https://github.com/jwiegley/use-package][Use-package]] installation and setup
   It can't install itself so we have to bootstrap it
   #+BEGIN_SRC emacs-lisp
     (unless (package-installed-p 'use-package)
       (package-refresh-contents)
       (package-install 'use-package))

     (eval-when-compile
       (require 'use-package))

     (put 'use-package 'lisp-indent-function 1)

     (use-package use-package-core
       :custom
       ;; (use-package-verbose t)
       ;; (use-package-minimum-reported-time 0.005)
       (use-package-enable-imenu-support t))
   #+END_SRC

   Now we can enable [[https://gitlab.com/koral/gcmh][the Garbage Collector Magic Hack]]
   #+begin_src emacs-lisp
     (use-package gcmh
       :ensure t
       :demand t
       :config
       (gcmh-mode 1))
   #+end_src


   Use use-package to extend its own functionality by some more useful keywords.
   #+BEGIN_SRC emacs-lisp
     (use-package system-packages
       :ensure t
       :custom
       (system-packages-noconfirm t))

     (use-package use-package-ensure-system-package :ensure t)
   #+END_SRC
*** [[https://github.com/quelpa/quelpa][Quelpa]] "is a tool to compile and install Emacs Lisp packages locally from local or remote source code"

    #+BEGIN_SRC emacs-lisp
      (use-package quelpa
        :ensure t
        :defer t
        :custom
        (quelpa-update-melpa-p nil "Don't update the MELPA git repo."))

      (use-package quelpa-use-package
        :ensure t)

    #+END_SRC
    No more manual package installation, now we can install packages directly from github.

    This one tries to speed up Emacs startup a little bit
    #+BEGIN_SRC emacs-lisp
      (use-package fnhh
        :quelpa
        (fnhh :repo "a13/fnhh" :fetcher github)
        :config
        (fnhh-mode 1))
    #+END_SRC

    This adds  [[https://github.com/a13/use-package-custom-update][:custom-update]] keyword to use-package.
    #+BEGIN_SRC emacs-lisp
      (use-package use-package-custom-update
        :quelpa
        (use-package-custom-update
         :repo "a13/use-package-custom-update"
         :fetcher github
         :version original))
    #+END_SRC

** [[http://github.com/larstvei/try][Try]] packages without installing
   #+begin_src emacs-lisp
     (use-package try
       :ensure t
       :defer t)
   #+end_src

** [[https://github.com/Malabarba/paradox][Modernized Package Menu]]
   #+BEGIN_SRC emacs-lisp
     (use-package paradox
       :ensure t
       :defer 1
       :config
       (paradox-enable))

   #+END_SRC

* Global defaults
** Common
   These were defined in C code, so use ~emacs~ pseudo-package to set them.
   #+BEGIN_SRC emacs-lisp
     (use-package emacs
       :load-path "secrets"
       :init
       (put 'narrow-to-region 'disabled nil)
       (put 'downcase-region 'disabled nil)
       (fset 'x-popup-menu #'ignore)
       :custom
       (frame-resize-pixelwise t)
       (default-frame-alist '((menu-bar-lines 0)
                              (tool-bar-lines 0)
                              (vertical-scroll-bars)))
       (scroll-step 1)
       (inhibit-startup-screen t "Don't show splash screen")
       (use-dialog-box nil "Disable dialog boxes")
       (x-gtk-use-system-tooltips nil)
       (use-file-dialog nil)
       (enable-recursive-minibuffers t "Allow minibuffer commands in the minibuffer")
       (indent-tabs-mode nil "Spaces!")
       (tab-width 4)
       (debug-on-quit nil)
       :config
       ;; Terminal emacs doesn't have it
       (when (fboundp 'set-fontset-font)
         ;; a workaround for old charsets
         (set-fontset-font "fontset-default" 'cyrillic
                           (font-spec :registry "iso10646-1" :script 'cyrillic))
         ;; TODO: is it possible to not hardcode fonts?
         (set-fontset-font t 'symbol
                           (font-spec :family
                                      (if (eq system-type 'darwin)
                                          "Apple Color Emoji"
                                        "Symbola"))
                           nil 'prepend)))

   #+END_SRC
** Default keybindings customization and other built-in settings

   Disable suspending on /C-z/
   #+BEGIN_SRC emacs-lisp
     (use-package frame
       :bind
       ("C-z" . nil)
       :custom
       (initial-frame-alist '((vertical-scroll-bars))))
   #+END_SRC

   /C-c C-g/ always quits minubuffer
   #+BEGIN_SRC emacs-lisp
     (use-package delsel
       :bind
       (:map mode-specific-map
             ("C-g" . minibuffer-keyboard-quit)))
   #+END_SRC

   Make /C-w/ and /C-h/ kill a word/char before cursor (see [[http://unix-kb.cat-v.org/][Unix keyboard shortcuts]], don't know what to do with /C-u/ though).

   NB: rebinding /C-h/ breaks /M-x kmacro-edit-lossage/, so you have to use something like /M-x edit-kbd-macro RET F1-l/ instead.
   #+BEGIN_SRC emacs-lisp
     (use-package simple
       :defer 0.1
       :custom
       (kill-ring-max 30000)
       (column-number-mode 1)
       :config
       (toggle-truncate-lines 1)
       :bind
       ;; remap ctrl-w/ctrl-h
       (("C-w" . backward-kill-word)
        ("C-h" . delete-backward-char)
        :map ctl-x-map
        ("C-k" . kill-region)
        ("K" . kill-current-buffer)))
   #+END_SRC

   But we still need to access help somehow
   #+BEGIN_SRC emacs-lisp
     (use-package help
       :defer t
       :bind
       (("C-?" . help-command)
        :map mode-specific-map
        ("h" . help-command)))
   #+END_SRC

   Who uses list-buffers?
   #+BEGIN_SRC emacs-lisp
     (use-package ibuffer
       :bind
       ([remap list-buffers] . ibuffer))
   #+END_SRC


** Files
   Saving
   #+BEGIN_SRC emacs-lisp
     (use-package files
       :hook
       (before-save . delete-trailing-whitespace)
       :custom
       (require-final-newline t)
       ;; backup settings
       (backup-by-copying t)
       (backup-directory-alist
        `((".*" . ,(locate-user-emacs-file "backups"))))
       (delete-old-versions t)
       (kept-new-versions 6)
       (kept-old-versions 2)
       (version-control t))

     (use-package autorevert
       :defer 0.1)
   #+END_SRC

   #+begin_src emacs-lisp
     (use-package recentf
       :defer 0.1
       :custom
       (recentf-auto-cleanup 30)
       :config
       (recentf-mode)
       (run-with-idle-timer 30 t 'recentf-save-list))
   #+end_src

   [[https://github.com/a13/iqa.el][Quick access to init files]]
   #+BEGIN_SRC emacs-lisp
     (use-package iqa
       :ensure t
       :custom
       (iqa-user-init-file (locate-user-emacs-file "README.org")
                           "Edit README.org by default.")
       :config
       (iqa-setup-default))
   #+END_SRC

   I don't use [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Easy-Customization.html][Customize]], so put [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Saving-Customizations.html][custom-file]] "nowhere".
   #+BEGIN_SRC emacs-lisp
     (use-package cus-edit
       :defer t
       :custom
       ;; (custom-file (make-temp-file "emacs-custom") "Store customizations in a temp file")
       (custom-file null-device "Don't store customizations"))
   #+END_SRC

   Somehow file-related too
   #+BEGIN_SRC emacs-lisp
     (use-package vlf
       :defer t
       :ensure t
       :after (ivy counsel)
       :init
       (ivy-add-actions 'counsel-find-file '(("l" vlf "view large file"))))

     (use-package epa
       :defer t
       :custom
       (epg-gpg-program "gpg")
       (epa-pinentry-mode nil))

     (use-package uniquify
       :defer 0.1
       :custom
       (uniquify-buffer-name-style 'forward))
   #+END_SRC

** Tramp
   #+BEGIN_SRC emacs-lisp
     (use-package tramp
       :defer t
       :config
       (put 'temporary-file-directory 'standard-value `(,temporary-file-directory))
       :custom
       (tramp-backup-directory-alist backup-directory-alist)
       (tramp-default-method "ssh")
       (tramp-default-proxies-alist nil))

     (use-package sudo-edit
       :ensure t
       :config (sudo-edit-indicator-mode)
       :bind (:map ctl-x-map
                   ("M-s" . sudo-edit)))

   #+END_SRC
** Uncategorized
   [[https://github.com/purcell/exec-path-from-shell][Get environment variables from the shell]]
   #+BEGIN_SRC emacs-lisp
     (use-package exec-path-from-shell
       :ensure t
       :defer 0.1
       :config
       (exec-path-from-shell-initialize))

     (use-package xr
       :ensure t
       :defer t)
   #+END_SRC

* Eshell
  #+BEGIN_SRC emacs-lisp
    (use-package em-smart
      :defer t
      :config
      (eshell-smart-initialize)
      :custom
      (eshell-where-to-jump 'begin)
      (eshell-review-quick-commands nil)
      (eshell-smart-space-goes-to-end t))

    (use-package esh-help
      :ensure t
      :defer t
      :config
      (setup-esh-help-eldoc))

    (use-package esh-autosuggest
      :ensure t
      :hook (eshell-mode . esh-autosuggest-mode))

    (use-package esh-module
      :defer t
      :custom-update
      (eshell-modules-list '(eshell-tramp)))

    (use-package eshell-prompt-extras
      :ensure t
      :after (eshell esh-opt)
      :custom
      (eshell-prompt-function #'epe-theme-dakrone))

    (use-package eshell-toggle
      :ensure t
      :after projectile
      :custom
      (eshell-toggle-use-projectile-root t)
      (eshell-toggle-run-command nil)
      :bind
      ("M-`" . eshell-toggle))

    ;; (use-package eshell-fringe-status
    ;;   :ensure t
    ;;   :hook
    ;;   (eshell-mode . eshell-fringe-status-mode))
  #+END_SRC
* Dired
  #+BEGIN_SRC emacs-lisp
    (use-package ls-lisp
      :defer t
      :custom
      (ls-lisp-emulation 'MS-Windows)
      (ls-lisp-ignore-case t)
      (ls-lisp-verbosity nil))

    (use-package dired
      :custom (dired-dwim-target t "guess a target directory")
      :hook
      (dired-mode . dired-hide-details-mode))

    (use-package dired-x
      :bind
      ([remap list-directory] . dired-jump)
      :custom
      ;; do not bind C-x C-j since it's used by jabber.el
      (dired-bind-jump nil))

    (use-package dired-toggle
      :ensure t
      :defer t)

    (use-package dired-hide-dotfiles
      :ensure t
      :bind
      (:map dired-mode-map
            ("." . dired-hide-dotfiles-mode))
      :hook
      (dired-mode . dired-hide-dotfiles-mode))

    (use-package diredfl
      :ensure t
      :hook
      (dired-mode . diredfl-mode))

    (use-package async
      :ensure t
      :defer t
      :custom
      (dired-async-mode 1))

    (use-package dired-rsync
      :ensure t
      :bind
      (:map dired-mode-map
            ("r" . dired-rsync)))

    (use-package dired-launch
      :ensure t
      :hook
      (dired-mode . dired-launch-mode))

    (use-package dired-git-info
      :ensure t
      :bind
      (:map dired-mode-map
            (")" . dired-git-info-mode)))

    (use-package dired-recent
      :ensure t
      :bind
      (:map
       dired-recent-mode-map ("C-x C-d" . nil))
      :config
      (dired-recent-mode 1))
  #+END_SRC

* Interface

** Localization
   #+BEGIN_SRC emacs-lisp
     (use-package mule
       :defer 0.1
       :config
       (prefer-coding-system 'utf-8)
       (set-language-environment "UTF-8")
       (set-terminal-coding-system 'utf-8))

     (use-package ispell
       :defer t
       :custom
       (ispell-local-dictionary-alist
        '(("russian"
           "[АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЪЭЮЯабвгдеёжзийклмнопрстуфхцчшщьыъэюяіїєґ’A-Za-z]"
           "[^АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЬЫЪЭЮЯабвгдеёжзийклмнопрстуфхцчшщьыъэюяіїєґ’A-Za-z]"
           "[-']"  nil ("-d" "uk_UA,ru_RU,en_US") nil utf-8)))
       (ispell-program-name "hunspell")
       (ispell-dictionary "russian")
       (ispell-really-aspell nil)
       (ispell-really-hunspell t)
       (ispell-encoding8-command t)
       (ispell-silently-savep t))

     (use-package flyspell
       :defer t
       :custom
       (flyspell-delay 1))

     (use-package flyspell-correct-ivy
       :ensure t
       :bind (:map flyspell-mode-map
                   ("C-c $" . flyspell-correct-at-point)))
   #+END_SRC

** Fonts
   Provide [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Font-Selection.html][face-font-family-alternatives]] for all the fonts we are going to use to avoid errors in case of their absense.
   #+BEGIN_SRC emacs-lisp
     (use-package faces
       :custom
       (face-font-family-alternatives
        '(("Monospace" "courier" "fixed")
          ("Consolas" "Monaco" "Roboto Mono" "PT Mono" "Terminus" "Monospace")
          ("Monospace Serif" "CMU Typewriter Text" "Courier 10 Pitch" "Monospace")
          ("Serif" "Alegreya" "CMU Serif" "Georgia" "Cambria" "Times New Roman" "DejaVu Serif" "serif")))
       :custom-face
       (variable-pitch ((t (:family "Serif" :height 135))))
       (fixed-pitch ((t (:family "Monospace Serif" :height 125))))
       (default ((t (:family "Monospace Serif" :height 125)))))

     (use-package font-lock
       :defer t
       :custom-face
       (font-lock-comment-face ((t (:inherit font-lock-comment-face :italic t))))
       (font-lock-doc-face ((t (:inherit font-lock-doc-face :italic t))))
       (font-lock-string-face ((t (:inherit font-lock-string-face :italic t)))))
   #+END_SRC


** Color themes
   #+BEGIN_SRC emacs-lisp
     (use-package open-color
       :quelpa
       (open-color :repo "a13/open-color.el" :fetcher github :version original))

     (use-package lor-oc-theme
       :config
       (load-theme 'lor-oc t)
       :load-path "/home/dk/git/lor-theme"
       ;; :quelpa
       ;; (lor-theme :repo "a13/lor-theme" :fetcher github :version original)
       )
   #+END_SRC

** GUI
   (Almost) smooth mouse scrolling
   #+BEGIN_SRC emacs-lisp
     (use-package mwheel
       :custom
       (mouse-wheel-scroll-amount '(1
                                    ((shift) . 5)
                                    ((control))))
       (mouse-wheel-progressive-speed nil))

     (use-package pixel-scroll
       :config
       (pixel-scroll-mode))
   #+END_SRC

   Disable gui elements we don't need:
   #+BEGIN_SRC emacs-lisp
     (use-package tooltip
       :defer t
       :custom
       (tooltip-mode -1))
   #+END_SRC

   Add those we want instead:
   #+BEGIN_SRC emacs-lisp
     (use-package time
       :defer t
       :custom
       (display-time-default-load-average nil)
       (display-time-24hr-format t)
       (display-time-mode t))

     (use-package fancy-battery
       :ensure t
       :hook
       (after-init . fancy-battery-mode))

   #+END_SRC

   Fancy stuff
   #+BEGIN_SRC emacs-lisp
     (use-package olivetti
       :defer t
       :ensure t
       :custom
       (olivetti-body-width 95))

     (use-package font-lock+
       :defer t
       :quelpa
       (font-lock+ :repo "emacsmirror/font-lock-plus" :fetcher github))

     (use-package all-the-icons
       :ensure t
       :defer t
       :config
       (setq all-the-icons-mode-icon-alist
             `(,@all-the-icons-mode-icon-alist
               (package-menu-mode all-the-icons-octicon "package" :v-adjust 0.0)
               (jabber-chat-mode all-the-icons-material "chat" :v-adjust 0.0)
               (jabber-roster-mode all-the-icons-material "contacts" :v-adjust 0.0)
               (telega-chat-mode all-the-icons-fileicon "telegram" :v-adjust 0.0
                                 :face all-the-icons-blue-alt)
               (telega-root-mode all-the-icons-material "contacts" :v-adjust 0.0))))

     (use-package all-the-icons-dired
       :ensure t
       :hook
       (dired-mode . all-the-icons-dired-mode))

     (use-package all-the-icons-ivy
       :defer t
       :ensure t
       :after ivy
       :custom
       (all-the-icons-ivy-buffer-commands '() "Don't use for buffers.")
       :config
       (all-the-icons-ivy-setup))

     (use-package mood-line
       :ensure t
       :custom-face
       (mode-line ((t (:inherit default (:box (:line-width -1 :style released-button))))))
       :hook
       (after-init . mood-line-mode))
   #+END_SRC

   And the winner is…
   #+BEGIN_SRC emacs-lisp
     (use-package winner
       :config
       (winner-mode 1))
   #+END_SRC
** Highlighting
   #+BEGIN_SRC emacs-lisp
     (use-package paren
       :config
       (show-paren-mode t))

     (use-package hl-line
       :hook
       (prog-mode . hl-line-mode))

     (use-package highlight-numbers
       :ensure t
       :hook
       (prog-mode . highlight-numbers-mode))

     (use-package highlight-escape-sequences
       :ensure t
       :config (hes-mode))

     (use-package hl-todo
       :ensure t
       :custom-face
       (hl-todo ((t (:inherit hl-todo :italic t))))
       :hook ((prog-mode . hl-todo-mode)
              (yaml-mode . hl-todo-mode)))

     (use-package page-break-lines
       :ensure t
       :hook
       (help-mode . page-break-lines-mode)
       (prog-mode . page-break-lines-mode)
       (special-mode . page-break-lines-mode)
       (compilation-mode . page-break-lines-mode))

     (use-package rainbow-delimiters
       :ensure t
       :hook
       (prog-mode . rainbow-delimiters-mode))

     (use-package rainbow-identifiers
       :ensure t
       :custom
       (rainbow-identifiers-cie-l*a*b*-lightness 80)
       (rainbow-identifiers-cie-l*a*b*-saturation 50)
        ;; (rainbow-identifiers-choose-face-function
        ;;  #'rainbow-identifiers-cie-l*a*b*-choose-face)
       :hook
       (emacs-lisp-mode . rainbow-identifiers-mode) ; actually, turn it off
       (prog-mode . rainbow-identifiers-mode))

     (use-package rainbow-mode
       :ensure t
       :hook '(prog-mode help-mode))

     (use-package so-long
       :quelpa (so-long :url "https://raw.githubusercontent.com/emacs-mirror/emacs/master/lisp/so-long.el" :fetcher url)
       :config (global-so-long-mode))

   #+END_SRC

* Minibuffer (search, commands)
  I prefer [[https://github.com/abo-abo/swiper][Ivy/Counsel/Swiper]] over Helm
  #+BEGIN_SRC emacs-lisp
    ;; counsel-M-x can use this one
    (use-package amx :ensure t :defer t)

    (use-package ivy
      :ensure t
      :custom
      ;; (ivy-re-builders-alist '((t . ivy--regex-fuzzy)))
      (ivy-count-format "%d/%d " "Show anzu-like counter")
      (ivy-use-selectable-prompt t "Make the prompt line selectable")
      :custom-face
      (ivy-current-match ((t (:inherit 'hl-line))))
      :bind
      (:map mode-specific-map
            ("C-r" . ivy-resume))
      :config
      (ivy-mode t))

    (use-package ivy-xref
      :ensure t
      :defer t
      :custom
      (xref-show-xrefs-function #'ivy-xref-show-xrefs "Use Ivy to show xrefs"))

    (use-package counsel
      :ensure t
      :bind
      (([remap menu-bar-open] . counsel-tmm)
       ([remap insert-char] . counsel-unicode-char)
       ([remap isearch-forward] . counsel-grep-or-swiper)
       :map mode-specific-map
       :prefix-map counsel-prefix-map
       :prefix "c"
       ("a" . counsel-apropos)
       ("b" . counsel-bookmark)
       ("B" . counsel-bookmarked-directory)
       ("c w" . counsel-colors-web)
       ("c e" . counsel-colors-emacs)
       ("d" . counsel-dired-jump)
       ("f" . counsel-file-jump)
       ("F" . counsel-faces)
       ("g" . counsel-org-goto)
       ("h" . counsel-command-history)
       ("H" . counsel-minibuffer-history)
       ("i" . counsel-imenu)
       ("j" . counsel-find-symbol)
       ("l" . counsel-locate)
       ("L" . counsel-find-library)
       ("m" . counsel-mark-ring)
       ("o" . counsel-outline)
       ("O" . counsel-find-file-extern)
       ("p" . counsel-package)
       ("r" . counsel-recentf)
       ("s g" . counsel-grep)
       ("s r" . counsel-rg)
       ("s s" . counsel-ag)
       ("t" . counsel-org-tag)
       ("v" . counsel-set-variable)
       ("w" . counsel-wmctrl)
       :map help-map
       ("F" . counsel-describe-face))
      :custom
      (counsel-grep-base-command
       "rg -i -M 120 --no-heading --line-number --color never %s %s")
      (counsel-search-engines-alist
       '((google
          "http://suggestqueries.google.com/complete/search"
          "https://www.google.com/search?q="
          counsel--search-request-data-google)
         (ddg
          "https://duckduckgo.com/ac/"
          "https://duckduckgo.com/html/?q="
          counsel--search-request-data-ddg)))
      :init
      (counsel-mode))

    (use-package swiper :ensure t)

    (use-package counsel-web
      :defer t
      :quelpa
      (counsel-web :repo "mnewt/counsel-web" :fetcher github))

    (use-package counsel-world-clock
      :ensure t
      :after counsel
      :bind
      (:map counsel-prefix-map
            ("C" .  counsel-world-clock)))

    (use-package ivy-rich

      :ensure t
      :config
      (ivy-rich-project-root-cache-mode t)
      (ivy-rich-mode 1))

    (use-package helm-make
      :defer t
      :ensure t
      :custom (helm-make-completion-method 'ivy))

  #+END_SRC
  Usually, I don't use isearch, but just in case
  #+BEGIN_SRC emacs-lisp
    (use-package isearch
      :bind
      ;; TODO: maybe get a keybinding from global map
      (:map isearch-mode-map
            ("C-h" . isearch-delete-char)))

    (use-package char-fold
      :defer 0.2
      :custom
      (char-fold-symmetric t)
      (search-default-mode #'char-fold-to-regexp)
      :quelpa (char-fold :url "https://raw.githubusercontent.com/emacs-mirror/emacs/master/lisp/char-fold.el"
                         :fetcher url))

  #+END_SRC
  Indicate minibuffer depth
  #+BEGIN_SRC emacs-lisp
    (use-package mb-depth
      :config
      (minibuffer-depth-indicate-mode 1))
  #+END_SRC
* Quick jumps
  Ace-jump is dead, long live [[https://github.com/abo-abo/avy][Avy]]!
  #+BEGIN_SRC emacs-lisp
    (use-package avy
      :ensure t
      :bind
      (("C-:" .   avy-goto-char-timer)
       ("C-." .   avy-goto-word-1)
       :map goto-map
       ("M-g" . avy-goto-line)
       :map search-map
       ("M-s" . avy-goto-word-1)))

    (use-package ivy-avy
      :after (ivy avy)
      :ensure t)

    (use-package avy-zap
      :defer t
      :ensure t
      :bind
      ([remap zap-to-char] . avy-zap-to-char))

    (use-package ace-jump-buffer
      :ensure t
      :bind
      (:map goto-map
            ("b" . ace-jump-buffer)))

    (use-package ace-window
      :ensure t
      :custom
      (aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l) "Use home row for selecting.")
      (aw-scope 'frame "Highlight only current frame.")
      :bind
      ("M-o" . ace-window))

    (use-package link-hint
      :ensure t
      :bind
      (("" . link-hint-open-link)
       ("S-" . link-hint-copy-link)
       :map mode-specific-map
       :prefix-map link-hint-keymap
       :prefix "l"
       ("o" . link-hint-open-link)
       ("c" . link-hint-copy-link)))

    (use-package ace-link
      :ensure t
      :after link-hint ; to use prefix keymap
      :bind
      (:map link-hint-keymap
            ("l" . counsel-ace-link))
      :config
      (ace-link-setup-default))


  #+END_SRC

* Regions/Kill ring/Clipboard
  #+BEGIN_SRC emacs-lisp
    (use-package select
      :custom
      (selection-coding-system 'utf-8)
      (select-enable-clipboard t "Use the clipboard"))

    (use-package expand-region
      :ensure t
      :bind
      (("C-=" . er/expand-region)
       ("C-+" . er/contract-region)
       :map mode-specific-map
       :prefix-map region-prefix-map
       :prefix "r"
       ("(" . er/mark-inside-pairs)
       (")" . er/mark-outside-pairs)
       ("'" . er/mark-inside-quotes)
       ([34] . er/mark-outside-quotes) ; it's just a quotation mark
       ("o" . er/mark-org-parent)
       ("u" . er/mark-url)
       ("b" . er/mark-org-code-block)
       ("." . er/mark-method-call)
       (">" . er/mark-next-accessor)
       ("w" . er/mark-word)
       ("d" . er/mark-defun)
       ("e" . er/mark-email)
       ("," . er/mark-symbol)
       ("<" . er/mark-symbol-with-prefix)
       (";" . er/mark-comment)
       ("s" . er/mark-sentence)
       ("S" . er/mark-text-sentence)
       ("p" . er/mark-paragraph)
       ("P" . er/mark-text-paragraph)))

    (use-package elec-pair
      :config
      (electric-pair-mode))

    (use-package edit-indirect
      :ensure t
      :after expand-region ; to use region-prefix-map
      :bind
      (:map region-prefix-map
            ("r" . edit-indirect-region)))

    (use-package clipmon
      :ensure t
      :defer 0.1
      :config
      (clipmon-mode))

    (use-package copy-as-format
      :ensure t
      :custom
      (copy-as-format-default "slack" "or Telegram")
      :bind
      (:map mode-specific-map
            :prefix-map copy-as-format-prefix-map
            :prefix "f"
            ("f" . copy-as-format)
            ("a" . copy-as-format-asciidoc)
            ("b" . copy-as-format-bitbucket)
            ("d" . copy-as-format-disqus)
            ("g" . copy-as-format-github)
            ("l" . copy-as-format-gitlab)
            ("c" . copy-as-format-hipchat)
            ("h" . copy-as-format-html)
            ("j" . copy-as-format-jira)
            ("m" . copy-as-format-markdown)
            ("w" . copy-as-format-mediawiki)
            ("o" . copy-as-format-org-mode)
            ("p" . copy-as-format-pod)
            ("r" . copy-as-format-rst)
            ("s" . copy-as-format-slack)))

    (use-package hungry-delete
      :ensure t
      :hook
      (text-mode . hungry-delete-mode)
      (prog-mode . hungry-delete-mode))

  #+END_SRC

* Help
  #+BEGIN_SRC emacs-lisp
    (use-package man
      :defer t
      :custom
      (Man-notify-method 'pushy "show manpage HERE")
      :custom-face
      (Man-overstrike ((t (:inherit font-lock-type-face :bold t))))
      (Man-underline ((t (:inherit font-lock-keyword-face :underline t)))))

    (use-package woman
      :defer t
      :custom-face
      (woman-bold ((t (:inherit font-lock-type-face :bold t))))
      (woman-italic ((t (:inherit font-lock-keyword-face :underline t)))))

    (use-package info-colors
      :ensure t
      :hook
      (Info-selection #'info-colors-fontify-node))

    (use-package keyfreq
      :defer 0.1
      :ensure t
      :config
      (keyfreq-mode 1)
      (keyfreq-autosave-mode 1))

    (use-package which-key
      :ensure t
      :custom
      (which-key-show-transient-maps t)
      :config
      (which-key-mode))

    (use-package free-keys
      :ensure t
      :defer t
      :commands free-keys)

    (use-package helpful
      :ensure t
      :defer t)
  #+END_SRC

* Internet
** Jabber
   #+BEGIN_SRC emacs-lisp
     ;; (use-package jabber
     ;;   :defer t
     ;;   :config
     ;;   (setq jabber-history-enabled t
     ;;         jabber-use-global-history nil
     ;;         fsm-debug nil)
     ;;   :custom
     ;;   (jabber-auto-reconnect t)
     ;;   (jabber-chat-buffer-format "*-jc-%n-*")
     ;;   (jabber-groupchat-buffer-format "*-jg-%n-*")
     ;;   (jabber-chat-foreign-prompt-format "▼ [%t] %n> ")
     ;;   (jabber-chat-local-prompt-format "▲ [%t] %n> ")
     ;;   (jabber-muc-colorize-foreign t)
     ;;   (jabber-muc-private-buffer-format "*-jmuc-priv-%g-%n-*")
     ;;   (jabber-rare-time-format "%e %b %Y %H:00")
     ;;   (jabber-resource-line-format "   %r - %s [%p]")
     ;;   (jabber-roster-buffer "*-jroster-*")
     ;;   (jabber-roster-line-format "%c %-17n")
     ;;   (jabber-roster-show-bindings nil)
     ;;   (jabber-roster-show-title nil)
     ;;   (jabber-roster-sort-functions (quote (jabber-roster-sort-by-status jabber-roster-sort-by-displayname jabber-roster-sort-by-group)))
     ;;   (jabber-show-offline-contacts nil)
     ;;   (jabber-show-resources nil))

     ;; (use-package jabber-otr
     ;;   :ensure t
     ;;   :defer t)

     ;; (use-package secrets-jabber
     ;;   :defer t
     ;;   :load t
     ;;   :after jabber)

     ;; (use-package point-im
     ;;   :defer t
     ;;   :defines point-im-reply-id-add-plus
     ;;   :after jabber
     ;;   :quelpa
     ;;   (point-im :repo "a13/point-im.el" :fetcher github :version original)
     ;;   :custom
     ;;   (point-im-reply-id-add-plus nil)
     ;;   :hook
     ;;   (jabber-chat-mode . point-im-mode))

   #+END_SRC

** Slack
   #+BEGIN_SRC emacs-lisp
     (use-package slack
       :ensure t
       :defer t
       :commands (slack-start)
       :custom
       (slack-buffer-emojify t "enable emoji")
       (slack-prefer-current-team t))

     ;; (use-package secrets-slack
     ;;   :load t
     ;;   :after slack)

     ;; TODO: move somewhere
     (use-package alert
       :defer t
       :ensure t
       :commands (alert)
       :custom
       (alert-default-style 'libnotify))

   #+END_SRC
** Web

   #+BEGIN_SRC emacs-lisp
     (use-package shr
       :defer t
       :custom
       (shr-use-fonts nil))

     (use-package shr-color
       :defer t
       :custom
       (shr-color-visible-luminance-min 80 "Improve the contrast"))

     (use-package eww
       :defer t
       :custom
       (eww-search-prefix "https://duckduckgo.com/html/?kd=-1&q="))

     (use-package browse-url
       :bind
       ([f5] . browse-url))

     (use-package bruh
       :defer t
       :after browse-url
       :quelpa
       (bruh :repo "a13/bruh" :fetcher github)
       :custom-update
       (bruh-images-re
        '("^https?://img-fotki\\.yandex\\.ru/get/"
          "^https?://pics\\.livejournal\\.com/.*/pic/"
          "^https?://l-userpic\\.livejournal\\.com/"
          "^https?://img\\.leprosorium\\.com/[0-9]+$"))
       :custom
       (browse-url-browser-function #'bruh-browse-url)
       (bruh-default-browser #'bruh-chromium-new-app)
       (bruh-videos-browser-function #'bruh-mpv))


     (use-package webjump
       :bind
       (([S-f5] . webjump))
       :config
       (setq webjump-sites
             (append '(("debian packages" .
                        [simple-query "packages.debian.org" "http://packages.debian.org/" ""]))
                     webjump-sample-sites)))

     (use-package atomic-chrome
       :defer 0.3
       :ensure t
       :custom
       (atomic-chrome-url-major-mode-alist
        '(("reddit\\.com" . markdown-mode)
          ("github\\.com" . gfm-mode)
          ("redmine" . textile-mode))
        "Major modes for URLs.")
       :config
       (atomic-chrome-start-server))

     (use-package shr-tag-pre-highlight
       :ensure t
       ;;:defer t
       :after shr
       :custom-update
       (shr-external-rendering-functions
        '((pre . shr-tag-pre-highlight))))

     (use-package google-this
       :defer 0.1
       :ensure t
       :bind
       (:map mode-specific-map
             ("g" . #'google-this-mode-submap)))

     (use-package multitran
       :ensure t
       :defer t)

     (use-package imgbb
       :ensure t
       :defer t)
   #+END_SRC

* Org
  #+BEGIN_SRC emacs-lisp
    (use-package calendar
      :defer t
      :custom
      (calendar-week-start-day 1))

    (use-package org
      :defer t
      ;; to be sure we have the latest Org version
      ;; :ensure org-plus-contrib
      :hook
      (org-mode . variable-pitch-mode)
      (org-mode . visual-line-mode)
      :custom
      (org-adapt-indentation t)
      (org-src-tab-acts-natively t))

    ;; (use-package org-passwords
    ;;   :ensure org-plus-contrib
    ;;   :bind
    ;;   (:map org-mode-map
    ;;         ("C-c C-p p" . org-passwords-copy-password)
    ;;         ("C-c C-p u" . org-passwords-copy-username)
    ;;         ("C-c C-p o" . org-passwords-open-url)))

     (use-package org-bullets
      :ensure t
      :custom
      ;; org-bullets-bullet-list
      ;; default: "◉ ○ ✸ ✿"
      ;; large: ♥ ● ◇ ✚ ✜ ☯ ◆ ♠ ♣ ♦ ☢ ❀ ◆ ◖ ▶
      ;; Small: ► • ★ ▸
      (org-bullets-bullet-list '("•"))
      ;; others: ▼, ↴, ⬎, ⤷,…, and ⋱.
      ;; (org-ellipsis "⤵")
      (org-ellipsis "…")
      :hook
      (org-mode . org-bullets-mode))

    (use-package htmlize
      :ensure t
      :defer t
      :custom
      (org-html-htmlize-output-type 'css)
      (org-html-htmlize-font-prefix "org-"))

    (use-package org-jira
      :defer t
      :ensure t
      :init
      (make-directory "~/.org-jira" t))

    ;; (use-package secrets-jira)
  #+END_SRC

* Writing

** Thesaurus
   #+begin_src emacs-lisp
     (use-package synosaurus
       :defer t
       :ensure t
       :custom
       (synosaurus-choose-method 'default)
       :config
       (synosaurus-mode))
   #+end_src

** Style
   #+begin_src emacs-lisp
     (use-package writegood-mode
       :defer t
       :ensure t)

     (use-package flycheck-grammarly
       :defer t
       :quelpa
       (flycheck-grammarly :repo "jcs-elpa/flycheck-grammarly"  :fetcher github))
   #+end_src

* Programming-related

  #+BEGIN_SRC emacs-lisp
    (use-package ibuffer-vc
      :defer t
      :ensure t
      :config
      (define-ibuffer-column icon
        (:name "Icon" :inline t)
        (all-the-icons-ivy--icon-for-mode major-mode))
      :custom
      (ibuffer-formats
       '((mark modified read-only vc-status-mini " "
               (name 18 18 :left :elide)
               " "
               (size 9 -1 :right)
               " "
               (mode 16 16 :left :elide)
               " "
               filename-and-process)) "include vc status info")
      :hook
      (ibuffer . (lambda ()
                   (ibuffer-vc-set-filter-groups-by-vc-root)
                   (unless (eq ibuffer-sorting-mode 'alphabetic)
                     (ibuffer-do-sort-by-alphabetic)))))

    (use-package git-modes
      :ensure t
      :defer t)

    (use-package generic-x)

    (use-package magit
      :ensure t
      :custom
      (magit-clone-default-directory (expand-file-name "~/git/"))
      (magit-completing-read-function 'ivy-completing-read "Force Ivy usage.")
      :bind
      (:map mode-specific-map
            :prefix-map magit-prefix-map
            :prefix "m"
            (("a" . magit-stage-file) ; the closest analog to git add
             ("b" . magit-blame)
             ("B" . magit-branch)
             ("c" . magit-checkout)
             ("C" . magit-commit)
             ("d" . magit-diff)
             ("D" . magit-discard)
             ("f" . magit-fetch)
             ("g" . vc-git-grep)
             ("G" . magit-gitignore)
             ("i" . magit-init)
             ("l" . magit-log)
             ("m" . magit)
             ("M" . magit-merge)
             ("n" . magit-notes-edit)
             ("p" . magit-pull-branch)
             ("P" . magit-push-current)
             ("r" . magit-reset)
             ("R" . magit-rebase)
             ("s" . magit-status)
             ("S" . magit-stash)
             ("t" . magit-tag)
             ("T" . magit-tag-delete)
             ("u" . magit-unstage)
             ("U" . magit-update-index))))

    (use-package forge
      :defer t
      :after magit
      :ensure t)

    (use-package git-timemachine
      :ensure t
      :defer t)

    (use-package browse-at-remote
      :ensure t
      :after link-hint
      :bind
      (:map link-hint-keymap
            ("r" . browse-at-remote)
            ("k" . browse-at-remote-kill)))

    (use-package smerge-mode
      :defer t)

    (use-package diff-hl
      :ensure t
      :hook
      ((magit-post-refresh . diff-hl-magit-post-refresh)
       (prog-mode . diff-hl-mode)
       (org-mode . diff-hl-mode)
       (dired-mode . diff-hl-dired-mode)))

    (use-package smart-comment
      :ensure t
      :bind ("M-;" . smart-comment))

    (use-package projectile
      :defer 0.2
      :ensure t
      :bind
      (:map mode-specific-map ("p" . projectile-command-map))
      :custom
      (projectile-create-missing-test-files t)
      (projectile-project-root-files-functions
       '(projectile-root-local
         projectile-root-top-down
         projectile-root-bottom-up
         projectile-root-top-down-recurring))
      (projectile-completion-system 'ivy))

    (use-package counsel-projectile
      :ensure t
      :after counsel projectile
      :config
      (counsel-projectile-mode))
  #+END_SRC
** Search
   #+BEGIN_SRC emacs-lisp
     (use-package ag
       :ensure t
       :defer t
       :ensure-system-package (ag . silversearcher-ag)
       :custom
       (ag-highlight-search t "Highlight the current search term."))

     (use-package dumb-jump
       :ensure t
       :defer t
       :custom
       (dumb-jump-selector 'ivy)
       (dumb-jump-prefer-searcher 'ag))
   #+END_SRC
** Autocompletion

   [[http://company-mode.github.io/][Company]]. There's also Auto-Complete as an alternative.
   #+BEGIN_SRC emacs-lisp
     (use-package company
       :ensure t
       :bind
       (:map company-active-map
             ("C-n" . company-select-next-or-abort)
             ("C-p" . company-select-previous-or-abort))
       :hook
       (after-init . global-company-mode))

     (use-package company-quickhelp
       :ensure t
       :defer t
       :custom
       (company-quickhelp-delay 3)
       (company-quickhelp-mode 1))

     (use-package company-shell
       :ensure t
       :after company
       :defer t
       :custom-update
       (company-backends '(company-shell)))

   #+END_SRC
** Use hippie-expand

   #+BEGIN_SRC emacs-lisp
     (use-package hippie-exp
       :bind
       ([remap dabbrev-expand] . hippie-expand))
   #+END_SRC


** Snippets
   #+BEGIN_SRC emacs-lisp
     (use-package autoinsert
       :hook
       (find-file . auto-insert))

     (use-package yasnippet
       :defer 0.1
       :ensure t
       :custom
       (yas-prompt-functions '(yas-completing-prompt))
       :config
       (yas-reload-all)
       :hook
       ((prog-mode feature-mode)  . yas-minor-mode))

     (use-package doom-snippets
       :defer t
       :quelpa
       (doom-snippets
        :repo "hlissner/doom-snippets"
        :fetcher github
        :files ("*" (:exclude ".*" "README.md")))
       :after yasnippet)
   #+END_SRC

** Checking/linting
   #+BEGIN_SRC emacs-lisp
     (use-package flycheck
       :ensure t
       :hook
       (prog-mode . flycheck-mode))

     (use-package avy-flycheck
       :ensure t
       :defer t
       :config
       (avy-flycheck-setup))

     (use-package cov
       :ensure t
       :defer t)
   #+END_SRC

** Languages support

   [[https://xkcd.com/297/][https://imgs.xkcd.com/comics/lisp_cycles.png]]

*** Emacs Lisp

    #+BEGIN_SRC emacs-lisp
      (use-package lisp
        :hook
        (after-save . check-parens))

      (use-package elisp-mode
        :bind
        (:map emacs-lisp-mode-map
              ("C-c C-d C-d" . describe-function)
              ("C-c C-d d" . describe-function)
              ("C-c C-k" . eval-buffer)))

      (use-package highlight-defined
        :ensure t
        :custom
        (highlight-defined-face-use-itself t)
        :hook
        (help-mode . highlight-defined-mode)
        (emacs-lisp-mode . highlight-defined-mode))

      (use-package highlight-quoted
        :ensure t
        :hook
        (emacs-lisp-mode . highlight-quoted-mode))

      (use-package highlight-sexp
        :quelpa
        (highlight-sexp :repo "daimrod/highlight-sexp" :fetcher github :version original)
        :hook
        (clojure-mode . highlight-sexp-mode)
        (emacs-lisp-mode . highlight-sexp-mode)
        (lisp-mode . highlight-sexp-mode))

      (use-package eros
        :ensure t
        :hook
        (emacs-lisp-mode . eros-mode))

      (use-package suggest
        :ensure t
        :defer t)

      (use-package ipretty
        :defer t
        :ensure t
        :config
        (ipretty-mode 1))

      (use-package nameless
        :ensure t
        :hook
        (emacs-lisp-mode .  nameless-mode)
        :custom
        (nameless-global-aliases '())
        (nameless-private-prefix t))

      ;; bind-key can't bind to keymaps
      (use-package erefactor
        :ensure t
        :defer t)

      (use-package flycheck-package
        :ensure t
        :hook
        (emacs-lisp-mode . flycheck-package-setup))

      (use-package elsa
        :defer t
        :ensure t)

      (use-package flycheck-elsa
        :ensure t
        :hook
        (emacs-lisp-mode . flycheck-elsa-setup))

      ;; (use-package dash
      ;;   :custom
      ;;   (dash-enable-fontlock t))
    #+END_SRC

*** Scheme
    #+BEGIN_SRC emacs-lisp
      (use-package geiser
        :ensure t
        :defer t)
    #+END_SRC

*** Clojure

    #+BEGIN_SRC emacs-lisp
      (use-package clojure-mode
        :ensure t
        :defer t
        :config
        (define-clojure-indent
          (pfor 1)
          (if-let-failed? 'defun)
          (if-let-ok? 'defun)
          (when-let-failed? 'defun)
          (when-failed 'defun)
          (when-let-ok? 'defun)
          (attempt-all 'defun)
          (alet 'defun)
          (mlet 'defun)))

      (use-package clj-refactor
        :defer t
        :ensure t)

      (use-package anakondo
        :ensure t
        :hook
        (clojure-mode . anakondo-minor-mode)
        (clojurescript-mode . anakondo-minor-mode)
        (clojurec-mode . anakondo-minor-mode))

      (use-package flycheck-clj-kondo
        :ensure t)

      (use-package clojure-snippets
        :ensure t
        :defer t)

      (use-package cider
        :ensure t
        :defer t
        :custom
        (cider-repl-display-help-banner nil))

      (use-package kibit-helper
        :ensure t
        :defer t)

    #+END_SRC

*** Common Lisp

    Disabled for now…

    #+BEGIN_SRC emacs-lisp
      (use-package slime
        :ensure t
        :disabled
        :config
        (setq inferior-lisp-program "/usr/bin/sbcl"
              lisp-indent-function 'common-lisp-indent-function
              slime-complete-symbol-function 'slime-fuzzy-complete-symbol
              slime-startup-animation nil)
        (slime-setup '(slime-fancy)))
    #+END_SRC

*** Erlang
    #+BEGIN_SRC emacs-lisp
      (use-package erlang
        :ensure t
        :defer t
        :custom
        (erlang-compile-extra-opts '(debug_info))
        :config
        (require 'erlang-start))


      (use-package company-erlang
        :ensure t
        :hook
        (erlang-mode #'company-erlang-init))
    #+END_SRC

*** Go
    #+BEGIN_SRC emacs-lisp
      (use-package go-mode
        :ensure t
        :defer t
        :bind
        (:map go-mode-map
              ("M-." . godef-jump)
              ("M-]" . next-error)
              ("M-[" . previous-error))
        :hook
        (before-save . gofmt-before-save)
        :custom
        (gofmt-command "goimports")
        :init
        (setenv "GO111MODULE" "on")
        (or (getenv "GOPATH")
            (setenv "GOPATH" (expand-file-name "~/go")))
        (setenv "PATH" (concat (getenv "GOPATH") "/bin" ":" (getenv "PATH"))))

      (use-package company-go
        :after go-mode
        :ensure t
        :defer t
        :config
        (push 'company-go company-backends))

      (use-package go-guru
        :ensure t
        :hook
        (go-mode . go-guru-hl-identifier-mode))

      (use-package flycheck-golangci-lint
        :ensure t
        :hook
        (go-mode . flycheck-golangci-lint-setup))

      (use-package go-eldoc
        :ensure t
        :hook
        (go-mode . go-eldoc-setup))

    #+END_SRC

*** Lua

    #+BEGIN_SRC emacs-lisp
      (use-package lua-mode
        :ensure t
        :defer t)
    #+END_SRC

*** JS

    #+BEGIN_SRC emacs-lisp
      (use-package conkeror-minor-mode
        :ensure t
        :disabled
        :defer t
        :hook
        (js-mode . (lambda ()
                     (when (string-match "conkeror" (or (buffer-file-name) ""))
                       (conkeror-minor-mode 1)))))

      (use-package json-mode
        :ensure t
        :defer t)

      (use-package graphql-mode
        :ensure t
        :mode "\\.graphql\\'"
        :custom
        (graphql-url "http://localhost:8000/api/graphql/query"))

    #+END_SRC

*** Shell
    #+BEGIN_SRC emacs-lisp
      (use-package sh-script
        :mode (("zshecl" . sh-mode)
               ("\\.zsh\\'" . sh-mode))
        :custom
        ;; zsh
        (system-uses-terminfo nil))

      (use-package executable
        :hook
        (after-save . executable-make-buffer-file-executable-if-script-p))
    #+END_SRC
*** Configuration files
    #+BEGIN_SRC emacs-lisp
      (use-package apt-sources-list
        :ensure t)

      (use-package ssh-config-mode
        :ensure t
        :init
        (autoload 'ssh-config-mode "ssh-config-mode" t)
        :mode
        (("/\\.ssh/config\\'"     . ssh-config-mode)
         ("/sshd?_config\\'"      . ssh-config-mode)
         ("/known_hosts\\'"       . ssh-known-hosts-mode)
         ("/authorized_keys2?\\'" . ssh-authorized-keys-mode))
        :hook
        (ssh-config-mode . turn-on-font-lock))
    #+END_SRC

*** Markup
    #+BEGIN_SRC emacs-lisp
      (use-package markdown-mode
        :ensure t
        :ensure-system-package markdown
        :mode (("\\`README\\.md\\'" . gfm-mode)
               ("\\.md\\'"          . markdown-mode)
               ("\\.markdown\\'"    . markdown-mode))
        :custom
        (markdown-command "markdown"))

      (use-package jira-markup-mode
        :ensure t
        :defer t
        :after atomic-chrome
        :mode ("\\.confluence$" . jira-markup-mode)
        :custom-update
        (atomic-chrome-url-major-mode-alist
         '(("atlassian\\.net$" . jira-markup-mode))))

    #+END_SRC

*** Misc
    #+BEGIN_SRC emacs-lisp
      (use-package csv-mode
        :ensure t
        :mode
        (("\\.[Cc][Ss][Vv]\\'" . csv-mode)))

      (use-package groovy-mode
        :defer t
        :ensure t
        :custom
        (groovy-indent-offset 2))

      (use-package jenkinsfile-mode
        :defer t
        :quelpa
        (jenkinsfile-mode :repo "john2x/jenkinsfile-mode" :fetcher github))

      (use-package aql-mode
        :defer t
        :quelpa
        (aql-mode :repo "a13/aql-mode" :fetcher github)
        :mode
        (("\\.arango$" . aql-mode)))


      (use-package sfz-mode
        :defer t
        :ensure t)
    #+END_SRC

*** HTTP
    #+BEGIN_SRC emacs-lisp
      (use-package restclient
        :ensure t
        :mode
        ("\\.http\\'" . restclient-mode))

      (use-package restclient-test
        :ensure t
        :hook
        (restclient-mode-hook . restclient-test-mode))

      (use-package ob-restclient
        :ensure t
        :after org restclient
        :init
        (org-babel-do-load-languages
         'org-babel-load-languages
         '((restclient . t))))

      (use-package company-restclient
        :ensure t
        :after (company restclient)
        :custom-update
        (company-backends '(company-restclient)))
    #+END_SRC

* External utilities
** Network
   #+BEGIN_SRC emacs-lisp
     (use-package net-utils
       :ensure-system-package traceroute
       :bind
       (:map mode-specific-map
             :prefix-map net-utils-prefix-map
             :prefix "n"
             ("p" . ping)
             ("i" . ifconfig)
             ("w" . iwconfig)
             ("n" . netstat)
             ("p" . ping)
             ("a" . arp)
             ("r" . route)
             ("h" . nslookup-host)
             ("d" . dig)
             ("s" . smbclient)
             ("t" . traceroute)))
   #+END_SRC
** Docker
   #+BEGIN_SRC emacs-lisp
     (use-package docker
       :ensure t
       :bind
       (:map mode-specific-map
             ("d" . docker)))

     ;; not sure if these two should be here
     (use-package dockerfile-mode
       :ensure t
       :defer t
       :mode "Dockerfile\\'")

     (use-package docker-compose-mode
       :ensure t
       :defer t)
   #+END_SRC
** Kubernetes
   #+BEGIN_SRC emacs-lisp
     (use-package k8s-mode
       :ensure t
       :hook (k8s-mode . yas-minor-mode))

     (use-package kubernetes
       :ensure t
       :commands (kubernetes-overview))
   #+END_SRC

** Misc
   [[https://github.com/syohex/emacs-emamux][Tmux interaction]]
   #+BEGIN_SRC emacs-lisp
     (use-package emamux
       :ensure t
       :defer t)
   #+END_SRC

   Debian stuff
   #+BEGIN_SRC emacs-lisp
     (use-package debian-el
       :ensure t
       :defer t)
   #+END_SRC

* [[https://github.com/a13/reverse-im.el][Reverse-im]]

  Shortcuts with non-English layout.
  #+BEGIN_SRC emacs-lisp
    (use-package unipunct-ng
      :quelpa
      (unipunct-ng
       :fetcher url
       :url "https://raw.githubusercontent.com/a13/xkb-custom/master/contrib/unipunct-ng.el"))

    (use-package reverse-im
      :ensure t
      :demand t
      :after unipunct-ng char-fold
      :bind
      ("M-T" . reverse-im-translate-word)
      :custom
      (reverse-im-char-fold t)
      (reverse-im-read-char-advice-function #'reverse-im-read-char-exclude)
      (reverse-im-input-methods '("russian-unipunct-ng"))
      :config
      (reverse-im-mode t))
  #+END_SRC

* The end…

  #+BEGIN_SRC emacs-lisp :tangle no

    ;; Local Variables:
    ;; eval: (add-hook 'after-save-hook (lambda () (let ((inhibit-redisplay t) (inhibit-message t) (emacs-lisp-mode-hook '())) (org-babel-tangle))) nil t)
    ;; End:
    ;;; init.el ends here

  #+END_SRC

本源码包内暂不包含可直接显示的源代码文件,请下载源码包。