AfsmNGhr / dockemacs

(defmacro k-time (&rest body)
  "Measure and return the time it takes evaluating BODY."
  `(let ((time (current-time)))
     ,@body
     (float-time (time-since time))))

;; When idle for 15sec run the GC no matter what.
(defvar k-gc-timer
  (run-with-idle-timer 15 t
                       (lambda ()
                         (message "Garbage collector has run for %.06f sec"
                                  (k-time (garbage-collect))))))

(setq package-enable-at-startup nil
      package--init-file-ensured t)

(if (version< emacs-version "26.3")
  (setq gnutls-algorithm-priority "NORMAL:-VERS-TLS1.3"))

(if (getenv "TRAVIS")
    (setq package-check-signature nil))

(require 'package)
(package-initialize)

(setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                         ("org" . "http://orgmode.org/elpa/")
                         ("melpa" . "https://melpa.org/packages/")
                         ("melpa-stable" . "https://stable.melpa.org/packages/"))
      use-package-always-ensure t)

(unless (version< emacs-version "25.1")
  (setq package-archive-priorities '(("melpa-stable" . 30)
                                     ("gnu" . 10)
                                     ("melpa" . 20))))

(unless package-archive-contents
  (package-refresh-contents))

(let ((afsmnghr/packages '(use-package)))
  (dolist (p afsmnghr/packages)
    (unless (package-installed-p p)
      (package-install p))))

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

(use-package delight)

(use-package bind-key)

(use-package benchmark-init
  :init (benchmark-init/activate)
  :commands (benchmark-init/activate)
  :hook (emacs-startup . benchmark-init/deactivate))

(use-package cus-edit :defer t :ensure f
  :commands (customize-set-variable)
  :custom (custom-file null-device))

(fset 'yes-or-no-p 'y-or-n-p)

(menu-bar-mode -1)
(if tool-bar-mode
    (tool-bar-mode -1))
(column-number-mode -1)
(blink-cursor-mode -1)
(line-number-mode -1)
(size-indication-mode -1)
(setq ring-bell-function 'ignore)

(setq display-time-interval 1
      display-time-format "%H:%M"
      display-time-default-load-average nil)

(display-time-mode)

(setq use-dialog-box nil
      use-file-dialog nil
      epa-pinentry-mode 'loopback)

(setq show-paren-style 'mixed
      word-wrap t
      search-highlight t
      query-replace-highlight t
      select-enable-clipboard t
      echo-keystrokes 0.1
      enable-local-eval t)

(defun afsmnghr/load-theme ()
  "Load a theme"
  (add-to-list 'custom-theme-load-path "~/.emacs.d/themes")

  (if (display-graphic-p)
      (load-theme 'spolsky t)
    (load-theme 'spolsky-term t)))

(defun afsmnghr/enable-theme (frame)
  "Enable theme the current frame depending on the frame type"
  (with-selected-frame frame
    (if (window-system)
        (progn
          (unless (custom-theme-enabled-p 'spolsky)
            (if (custom-theme-enabled-p 'spolsky-term)
                (disable-theme 'spolsky-term))
            (enable-theme 'spolsky)))
      (progn
        (unless (custom-theme-enabled-p 'spolsky-term)
          (if (custom-theme-enabled-p 'spolsky)
              (disable-theme 'spolsky))
          (enable-theme 'spolsky-term))))))

(add-hook 'after-init-hook 'afsmnghr/load-theme)

;; don't change theme inside docker container
(unless (file-exists-p "/.dockerenv")
  (add-hook 'after-make-frame-functions 'afsmnghr/enable-theme))

(global-visual-line-mode t)
(global-font-lock-mode t)
(global-auto-revert-mode t)
(delete-selection-mode t)

(setq browse-url-browser-function 'browse-url-generic
      browse-url-generic-program "/usr/local/sbin/browser-remote")

(setq dired-listing-switches "-lhvA")

(prefer-coding-system 'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(setq buffer-file-coding-system 'utf-8
      file-name-coding-system 'utf-8)

(setq-default tab-width 2
              tab-always-indent 'complete
              indent-tabs-mode nil)

(use-package elec-pair :ensure f
  :commands electric-pair-mode
  :config (electric-pair-mode 1))

(use-package whitespace :ensure f
  :hook (prog-mode . whitespace-mode)
  :custom
  ((whitespace-line-column 120)
   (whitespace-style '(face lines-tail))))

(defun comment-or-uncomment-region-or-line ()
  "Comments or uncomments the region or the current line if there's no active region."
  (interactive)
  (let (beg end)
    (if (region-active-p)
        (setq beg (region-beginning) end (region-end))
      (setq beg (line-beginning-position) end (line-end-position)))
    (comment-or-uncomment-region beg end)
    (forward-line)))

(global-set-key (kbd "C-x w") 'kill-buffer-and-window)
(global-set-key (kbd "C-z") 'undo)

(global-set-key (kbd "C-x o") 'ace-window)

(global-set-key (kbd "C-w") 'clipboard-kill-region)
(global-set-key (kbd "M-w") 'clipboard-kill-ring-save)

(global-set-key (kbd "C-y") 'clipboard-yank)
(global-set-key (kbd "M-q") 'query-replace-regexp)

(global-set-key [remap comment-dwim] 'comment-or-uncomment-region-or-line)

(use-package reverse-im :defer 1
  :commands reverse-im-activate
  :config (reverse-im-activate "russian-computer"))

(setq history-length t
      history-delete-duplicates t
      savehist-save-minibuffer-history 1
      savehist-autosave-interval 60
      savehist-additional-variables '(search-ring regexp-search-ring
                                                  comint-input-ring))

(savehist-mode 1)

(setq backup-directory-alist '(("." . "~/.emacs.d/backups"))
      auto-save-file-name-transforms '((".*" "~/.emacs.d/auto-save-list/" t))
      delete-old-versions t
      version-control t
      vc-make-backup-files t
      backup-by-copying t
      kept-new-versions 2
      kept-old-versions 2)

(use-package recentf :defer t :ensure f
  :after ido
  :init (recentf-mode 1)
  :commands recentf-mode
  :custom ((recentf-max-saved-items 30)
           (recentf-keep '(file-remote-p file-readable-p)))
  :config (run-with-idle-timer 10 t 'recentf-save-list))

(use-package bookmark :defer t :ensure f
  :after ido
  :custom (bookmark-save-flag t)
  :commands (bookmark-jump bookmark-all-names)
  :preface
  (defun jump-to-bookmark ()
    (interactive)
    (bookmark-jump
     (ido-completing-read "Jump to bookmark: "
                          (bookmark-all-names))))
  :bind
  (:map global-map ("C-x r b" . jump-to-bookmark)))

(defadvice save-buffers-kill-emacs (around no-query-kill-emacs activate)
  "Prevent annoying \"Active processes exist\" query when you quit Emacs."
  (cl-letf (((symbol-function #'process-list) (lambda ())))
    ad-do-it))

(defun tangle-init ()
  "If the current buffer is 'init.org' the code-blocks are
tangled, and the tangled file is compiled."
  (when (equal (buffer-file-name)
               (expand-file-name (concat user-emacs-directory "init.org")))
    ;; Avoid running hooks when tangling.
    (let ((prog-mode-hook nil))
      (org-babel-tangle)
      (byte-compile-file (concat user-emacs-directory "init.el")))))

(defun afsmnghr/minibuffer-setup-hook ()
  (setq gc-cons-threshold most-positive-fixnum
        gc-cons-percentage 0.6))

(defun afsmnghr/minibuffer-exit-hook ()
  (setq gc-cons-threshold 5000000
        gc-cons-percentage 0.1))

(add-hook 'minibuffer-setup-hook #'afsmnghr/minibuffer-setup-hook)
(add-hook 'minibuffer-exit-hook #'afsmnghr/minibuffer-exit-hook)
(add-hook 'after-save-hook #'tangle-init)
(add-hook 'before-save-hook #'delete-trailing-whitespace)

(use-package ace-window :defer t
  :custom ((aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l))
           (aw-background nil)))

(use-package ido-hacks :defer 1)

(use-package flx-ido
  :after ido
  :commands (flx-ido-mode ido-everywhere flx-ido-mode)
  :init
  (ido-mode 1)
  (ido-everywhere 1)
  (flx-ido-mode 1)
  :custom
  ((flx-ido-threshold 1000)
   (ido-enable-flex-matching t)
   (ido-use-faces t)
   (ido-virtual-buffers t)
   (ido-auto-merge-work-directories-length -1)))

(use-package ido-completing-read+ :pin melpa-stable
  :after ido
  :commands ido-ubiquitous-mode
  :init (ido-ubiquitous-mode 1))

(use-package company :defer 30
  :init (global-company-mode t)
  :commands global-company-mode
  :preface
  (defvar company-mode/enable-yas t
    "Enable yasnippet for all backends.")

  (defun company-mode/backend-with-yas (backend)
    (if (or (not company-mode/enable-yas)
            (and (listp backend)
                 (member 'company-yasnippet backend)))
        backend
      (append (if (consp backend) backend (list backend))
              '(:with company-yasnippet))))
  :custom ((company-backends
            (mapcar #'company-mode/backend-with-yas
                    '((company-capf company-shell company-dabbrev company-abbrev
                       company-files company-etags company-keywords))))
           (company-idle-delay 1.0)
           (company-tooltip-flip-when-above t)))

(use-package company-flx :defer t
  :after company
  :commands company-flx-mode
  :init (with-eval-after-load 'company
          (company-flx-mode +1)))

(use-package company-ycmd :defer t
  :after company
  :commands company-ycmd-setup
  :init (company-ycmd-setup))

(use-package company-shell :defer t :after company)

(use-package magit :defer 1
  :unless (version< emacs-version "24.4")
  :custom
  ((magit-completing-read-function 'magit-ido-completing-read)
   (magit-branch-arguments nil)
   (magit-status-margin '(t "%Y-%m-%d %H:%M " magit-log-margin-width t 18))
   (magit-default-tracking-name-function 'magit-default-tracking-name-branch-only)
   (magit-set-upstream-on-push t)
   (magit-push-always-verify nil)
   (magit-restore-window-configuration t)
   (vc-handled-backends nil)))

(use-package git-timemachine :defer t
  :unless (version< emacs-version "24.4"))

(use-package smerge-mode :ensure f :defer t)

(use-package projectile :defer 1
  :delight '(:eval
             (propertize (concat " " (projectile-project-name))
                         'face '(:foreground "#FD971F")))
  :commands projectile-mode
  :init
  (projectile-mode)
  (define-key projectile-mode-map (kbd "C-c p") 'projectile-command-map)
  :custom
  ((projectile-enable-caching t)
   (projectile-use-git-grep t)
   (projectile-indexing-method 'native)
   (projectile-sort-order 'recentf)
   (projectile-switch-project-action 'projectile-dired)
   (projectile-file-exists-remote-cache-expire (* 10 60))
   (projectile-file-exists-local-cache-expire (* 5 60))
   (projectile-require-project-root nil)
   (projectile-idle-timer-seconds 60)
   (projectile-completion-system 'ido)))

(use-package flycheck :defer t
  :custom
  ((flycheck-check-syntax-automatically '(save mode-enabled))
   (flycheck-display-errors-delay .3)))

(use-package yasnippet :defer 15
  :commands yas-global-mode
  :config (yas-global-mode t))

(use-package ag :defer t)

(use-package keyword-search :defer t
  :bind ("C-c s" . keyword-search)
  :custom ((afsmnghr/search-alist
            '((t/ya-en-ru . "https://translate.yandex.ru/?text=%s&lang=en-ru")
             (t/ya-ru-en . "https://translate.yandex.ru/?text=%s&lang=ru-en")
             (alpine/pkgs . "https://pkgs.alpinelinux.org/packages?name=%s")
             (reddit . "https://www.reddit.com/search?q=%s")))
           (keyword-search-alist (append keyword-search-alist afsmnghr/search-alist))))

(use-package dumb-jump :defer t
  :bind (("M-g o" . dumb-jump-go-other-window)
         ("M-g j" . dumb-jump-go)
         ("M-g i" . dumb-jump-go-prompt)
         ("M-g x" . dumb-jump-go-prefer-external)
         ("M-g z" . dumb-jump-go-prefer-external-other-window))
  :custom ((dumb-jump-selector 'ido)
           (dumb-jump-prefer-searcher 'git-grep)
           (dumb-jump-force-searcher 'ag)))

(use-package docker :defer t
  :unless (version< emacs-version "24.4"))

(use-package dockerfile-mode :defer t
  :mode (("Dockerfile\\'" . dockerfile-mode)))

(use-package tramp :defer t :ensure f
  :custom
  ((auto-revert-remote-files t)
   (shell-file-name "/bin/sh" "alpine based")))

(use-package ruby-mode :defer t :ensure f
  :mode (("\\.cr\\'" . ruby-mode)
         (".irbrc" . ruby-mode)))

(use-package elixir-mode :defer t)

(use-package python :defer t :ensure f)

(use-package typescript-mode :defer t
  :custom (typescript-indent-level 2))

(use-package json :custom (js-indent-level 2))

(use-package js2-mode :defer t
  :mode (("\\.js\\'" . js2-mode)
         ("\\.json\\'" . javascript-mode))
  :commands js2-mode
  :custom
  ((js2-basic-offset 2)
   (js2-indent-switch-body t)
   (js2-auto-indent-p t)
   (js2-highlight-level 3)
   (js2-indent-on-enter-key t)))

(use-package markdown-mode :defer t)
(use-package css-mode :defer t)
(use-package sass-mode :defer t
  :mode (("\\.scss" . sass-mode)))
(use-package yaml-mode :defer t)
(use-package company-web :defer t)
(use-package web-mode :defer t
  :commands web-mode
  :mode (("\\.html?\\'" . web-mode)
         ("\\.erb\\'" . web-mode)
         ("\\.vue" . web-mode))
  :custom ((web-mode-markup-indent-offset 2)
           (web-mode-enable-auto-pairing t)
           (web-mode-enable-current-element-highlight t)
           (web-mode-enable-block-face t)
           (web-mode-enable-part-face t)))

(defun afsmnghr/before-kill-emacs ()
  (if (fboundp 'org-save-all-org-buffers)
      (org-save-all-org-buffers)))

(add-hook 'kill-emacs-hook #'afsmnghr/before-kill-emacs)

(use-package org :defer 5 :ensure f
  :config
  (custom-set-variables
   '(org-babel-load-languages
     (quote ((emacs-lisp . t) (python . t) (shell . t) (ruby . t) (js . t) (sql . t))))
   '(org-confirm-babel-evaluate nil))
  :custom
  ((org-log-done t)
   (org-directory (getenv "ORG_PATH"))
   (org-startup-indented t)
   (org-indent-mode-turns-on-hiding-stars nil)
   (org-todo-keywords
    '((sequence "TODO(t!)" "NEXT(n@/!)" "INPROGRESS(i!)" "HOLD(h@/!)"
                "DONE(d!)" "CANCELLED(c@/!)"))))
  :bind
  (:map global-map ("C-c a" . org-agenda)))

(use-package org-faces :ensure f
  :after org
  :custom
  ((org-todo-keyword-faces
    '(("INPROGRESS" :foreground "DodgerBlue2" :weight bold)
      ("HOLD" :foreground "firebrick2" :weight bold)
      ("NEXT" :foreground "OrangeRed2" :weight bold)))
   (org-priority-faces '((?A . (:foreground "firebrick2" :weight 'bold))
                         (?B . (:foreground "OrangeRed2"))
                         (?C . (:foreground "DodgerBlue2"))))))

(use-package org-src :ensure f
  :after org
  :custom
  ((org-src-fontify-natively t)
   (org-edit-src-content-indentation 2)
   (org-src-tab-acts-natively t)
   (org-src-preserve-indentation t)
   (org-src-window-setup 'current-window)
   (org-src-ask-before-returning-to-edit-buffer nil)))

(use-package org-agenda :ensure f
  :after org
  :custom
  ((org-agenda-files (list org-directory (concat org-directory "orgzly")))
   (org-agenda-start-on-weekday 1)
   (org-agenda-dim-blocked-tasks nil)
   (org-agenda-block-separator nil)
   (org-agenda-compact-blocks t)
   (org-agenda-skip-scheduled-if-done t)
   (org-agenda-skip-deadline-if-done t)
   (org-agenda-clockreport-parameter-plist
    (quote (:link t :maxlevel 9 :fileskip0 t :compact t :narrow 80)))))

(use-package org-protocol :ensure f :defer t
  :after org
  :custom (org-protocol-default-template-key "L"))

(use-package org-capture :ensure f :defer t
  :after org
  :preface
  (defconst afsmnghr/org-capture-templates
    '(("L" "Links" entry (file+olp+datetree afsmnghr/org-links)
       "* %c \n%U %?%:initial")
      ("d" "Diary" entry (file+olp+datetree afsmnghr/org-diary)
       "* %?\n%U\n"
       :clock-in t :jump-to-captured t)))
  :custom
  ((afsmnghr/org-diary (concat org-directory "diary.org"))
   (afsmnghr/org-links (concat org-directory "links.org"))
   (org-capture-templates afsmnghr/org-capture-templates))
  :bind
  (:map global-map ("C-c c" . org-capture)))

(use-package org-clock :ensure f :defer t
  :after org
  :commands org-clock-persistence-insinuate
  :custom
  ((org-clock-history-length 30)
   (org-clock-in-switch-to-state "INPROGRESS")
   (org-clock-continuously t)
   (org-clock-in-resume t)
   (org-clock-into-drawer t)
   (org-clock-out-remove-zero-time-clocks t)
   (org-clock-out-when-done t)
   (org-clock-auto-clock-resolution 'when-no-clock-is-running)
   (org-clock-persist 'history)
   (org-clock-clocked-in-display 'mode-line)
   (org-clock-persist-query-resume nil)
   (org-clock-report-include-clocking-task t))
  :config
  (org-clock-persistence-insinuate))

(use-package deft
  :commands deft
  :after org
  :bind
  (:map global-map ("C-c d" . deft)
   :map deft-mode-map ("C-c d f" . deft-find-file))
  :custom
  ((deft-default-extension "org")
   (deft-recursive t)
   (deft-directory (concat org-directory "notes"))
   (deft-use-filename-as-title nil)
   (deft-use-filter-string-for-filename t)
   (deft-auto-save-interval -1.0)
   (deft-file-naming-rules
     '((noslash . "-")
       (nospace . "-")
       (case-fn . downcase)))))