Here is my modal Emacs configuration that has been inspired by Xah Lee
(require 'package)
(setq package-enable-at-startup nil)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
(eval-and-compile
(unless (package-installed-p 'use-package)
(package-refresh-contents)
(package-install 'use-package))
(require 'use-package)
(setq use-package-always-ensure t))
(server-start)(custom-set-variables
'(scroll-bar-mode nil)
'(tool-bar-mode nil)
'(tooltip-mode nil) ; relegate tooltips to echo area only
'(menu-bar-mode nil)
'(delete-selection-mode t)
'(visible-bell t)
'(ring-bell-function 'ignore)
'(inhibit-startup-screen t)
'(mac-command-modifier 'control)
'(icicle-ido-like-mode nil)
'(icicle-mode nil)
'(make-backup-files nil)
'(auto-save-default nil)
'(backup-by-copying t)
'(bookmark-save-flag 1)
'(case-fold-search t)
'(scroll-conservatively 100)
'(show-paren-mode t)
'(truncate-lines t)
'(global-hl-line-mode t)
'(winner-mode t)
'(which-key-mode t)
'(powerline-image-apple-rgb t)
'(large-file-warning-threshold 100000000)
'(ns-pop-up-frames nil)
'(mc/always-run-for-all t)
'(mc/cmds-to-run-once '())
)
(defalias 'yes-or-no-p 'y-or-n-p)
(prefer-coding-system 'utf-8)
(put 'narrow-to-region 'disabled nil)
(use-package exec-path-from-shell
:ensure t
:config
(exec-path-from-shell-initialize))(eval-and-compile
(defmacro save-column (&rest body)
`(let ((column (current-column)))
(unwind-protect
(progn ,@body)
(move-to-column column))))
(put 'save-column 'lisp-indent-function 0)
(defun move-line-up ()
(interactive)
(save-column
(transpose-lines 1)
(forward-line -2)))
(defun move-line-down ()
(interactive)
(save-column
(forward-line 1)
(transpose-lines 1)
(forward-line -1)))
(defun replace-char (arg)
(interactive
(list
(read-char-exclusive)))
(delete-char 1)
(insert arg))
(defun xah-display-minor-mode-key-priority ()
"Print out minor mode's key priority.
URL `http://ergoemacs.org/emacs/minor_mode_key_priority.html'
Version 2017-01-27"
(interactive)
(mapc
(lambda (x) (prin1 (car x)) (terpri))
minor-mode-map-alist))
(defun eval-and-replace ()
"Replace the preceding sexp with its value."
(interactive)
(backward-kill-sexp)
(condition-case nil
(prin1 (eval (read (current-kill 0)))
(current-buffer))
(error (message "Invalid expression")
(insert (current-kill 0)))))
(defun revert-buffer-no-confirm ()
"Revert buffer without confirmation."
(interactive)
(revert-buffer t t))
(defun my-new-line-and-indent ()
(interactive)
(move-end-of-line 1)
(newline-and-indent))
(defun my-new-line-and-indent-above ()
(interactive)
(beginning-of-line)
(open-line 1)
(indent-according-to-mode))
(defun custom-eval-single ()
(interactive)
(if (or
(string-equal major-mode "xah-elisp-mode")
(string-equal major-mode "emacs-lisp-mode")
(string-equal major-mode "lisp-mode")
(string-equal major-mode "lisp-interaction-mode")
(string-equal major-mode "common-lisp-mode")
(string-equal major-mode "xah-clojure-mode")
(string-equal major-mode "scheme-mode"))
(eval-defun nil)
(if (or (eq major-mode 'js2-mode)
(eq major-mode 'html-mode)
(eq major-mode 'css-mode))
(run-js))
(if (string-equal major-mode "clojure-mode")
(cider-eval-sexp-at-point))
(if (eq major-mode 'python-mode)
(elpy-shell-send-region-or-buffer))))
(defun run-js ()
(interactive)
(shell-command (concat "node " (buffer-name))))
(defun custom-eval-double ()
(interactive)
(if (or
(string-equal major-mode "xah-elisp-mode")
(string-equal major-mode "emacs-lisp-mode")
(string-equal major-mode "lisp-mode")
(string-equal major-mode "lisp-interaction-mode")
(string-equal major-mode "common-lisp-mode")
(string-equal major-mode "clojure-mode")
(string-equal major-mode "xah-clojure-mode")
(string-equal major-mode "scheme-mode"))
(eval-region (region-beginning) (region-end) t)
(if (eq major-mode 'js2-mode)
(skewer-eval-last-expression))
(if (eq major-mode 'python-mode)
(elpy-shell-send-current-statement))))
(defun duplicate-line()
(interactive)
(move-beginning-of-line 1)
(kill-line)
(yank)
(open-line 1)
(next-line 1)
(yank)
)
(defun kde-open-in-terminal ()
(interactive)
(cond
((string-equal system-type "windows-nt")
(message "Microsoft Windows not supported. File a bug report or pull request."))
((string-equal system-type "darwin")
(let ((process-connection-type nil))
(shell-command (concat "open -a "
(shell-quote-argument "/Applications/iTerm.app")
" "
(shell-quote-argument (file-truename default-directory))))))
((string-equal system-type "gnu/linux")
(let ((process-connection-type nil))
(start-process "" nil "x-terminal-emulator"
(concat "--working-directory=" default-directory))))))
(defun run-marta ()
(interactive)
(shell-command "marta ."))
(defun run-iterm-here ()
(interactive)
(shell-command "open . -a iterm"))
(defun gen-bookmark-str()
(interactive)
(string-join (mapcar (lambda (elem)
(concat (car elem) ":" (cdr (assoc 'filename (cdr elem))))
) bookmark-alist) ";"))
)(eval-and-compile
(defun my/paste-in-minibuffer ()
(local-set-key (kbd "M-k") 'yank)
(local-set-key (kbd "C-v") 'yank)
(local-set-key (kbd "C-a") 'mark-whole-buffer))
(add-hook 'minibuffer-setup-hook 'my/paste-in-minibuffer))(use-package buffer-move
:after xah-fly-keys
:defer t
:ensure t)
(use-package ace-window
:defer t
:ensure t)
(use-package switch-window
:ensure t)
(use-package solarized-theme
:ensure t
:config
(setq solarized-use-variable-pitch nil)
(setq solarized-height-plus-1 1.0)
(setq solarized-height-plus-2 1.0)
(setq solarized-height-plus-3 1.0)
(setq solarized-height-plus-4 1.0)
(setq solarized-high-contrast-mode-line t)
(load-theme 'solarized-dark t))(use-package spaceline
:defer t
:ensure t
:config
(progn
(require 'spaceline-config)
;; (spaceline-emacs-theme)
(spaceline-helm-mode)
;; (setq powerline-default-separator 'wave)
(spaceline-compile)
))
(use-package powerline
:after all-the-icons
:defer t
:ensure t
:config
(setq powerline-default-separator 'slant))
(setq-default mode-line-format
'(
(:eval
(let* ((active (powerline-selected-window-active))
(mode-line-buffer-id (if active 'mode-line-buffer-id-inactive 'mode-line-buffer-id))
(mode-line (if active 'mode-line-inactive 'mode-line))
(face1 (if active 'powerline-inactive2 'powerline-active1))
(face2 (if active 'powerline-inactive1 'powerline-active2))
(face-bold1 (if active 'powerline-inactive-bold-2 'powerline-active-bold-1))
(face-bold2 (if active 'powerline-inactive-bold-1 'powerline-active-bold-2))
(separator-left (intern (format "powerline-%s-%s"
(powerline-current-separator)
(car powerline-default-separator-dir))))
(separator-right (intern (format "powerline-%s-%s"
(powerline-current-separator)
(cdr powerline-default-separator-dir))))
(ths (list
(powerline-raw " test" 'face1 'r)
))
(lhs (list
(powerline-raw (xah-get-current-mode-str) face-bold1 'l)
(powerline-raw "%* " face1 'l)
(mode-icon face1)
(powerline-buffer-id face-bold1 'l)
(powerline-raw " " face1 'l)
(powerline-narrow face1 'l)
(powerline-raw (custom-modeline-icon-vc face1) face1 'l)))
(rhs (list (powerline-raw global-mode-string face1 'r)
(custom-modeline-region-info face1)
(powerline-raw "%4l" face1 'r)
(powerline-raw ":" face1)
(powerline-raw "%3c" face1 'r)
(funcall separator-right face1 mode-line)
(powerline-raw " " mode-line)
(powerline-raw "%6p" mode-line 'r)
(powerline-buffer-size face1 'l)
(powerline-hud face2 face1)))
(center (list (powerline-raw " " face1)
(funcall separator-left face1 face2)
(when (and (boundp 'erc-track-minor-mode) erc-track-minor-mode)
(powerline-raw erc-modified-channels-object face2 'l))
(powerline-major-mode face2 'l)
(powerline-process face2)
(powerline-raw " :" face2)
(powerline-minor-modes face2 'l)
(powerline-raw " " face2)
(funcall separator-right face2 face1))))
(concat
(powerline-render lhs)
; (powerline-render ths)
(powerline-fill-center face1 (/ (powerline-width center) 2.0))
(powerline-render center)
(powerline-fill face1 (powerline-width rhs))
(powerline-render rhs)
)))))
(face-spec-set
'mode-line
'((t
:box (:line-width 1 :color "#002b36" :style unspecified)
:overline "#002b36"
)))
(defface powerline-active-bold-1
'((t
:weight bold
:inherit powerline-active1
))
"face"
:group 'powerline)
(defface powerline-active-bold-2
'((t
:weight bold
:inherit powerline-active2
))
"face"
:group 'powerline)
(defface powerline-inactive-bold-1
'((t
:weight bold
:inherit powerline-inactive1
))
"face"
:group 'powerline)
(defface powerline-inactive-bold-2
'((t
:weight bold
:inherit powerline-inactive2
))
"face"
:group 'powerline)
(defface my-xah-info
'(( t
:foreground "#839496"
:background "#0e5994"
:weight bold
))
"Face for global variables."
:group 'my-lang-mode )
(eval-and-compile
(defun mode-icon (face-value)
(let ((family (all-the-icons-icon-family-for-buffer))
(icon (all-the-icons-icon-for-buffer)))
(if (not (symbolp icon))
;; (propertize (symbol-name icon)
;; 'face `(:height 0.8 :inherit ,face-value)
;; 'display '(raise 0.1))
(propertize icon
'face `(:height 1.1 :family ,family :inherit ,face-value)
'display '(raise 0.0)
))))
(defun custom-modeline-region-info (face)
(when mark-active
(let ((words (count-lines (region-beginning) (region-end)))
(chars (count-words (region-end) (region-beginning))))
(concat
(propertize (format " %s" (all-the-icons-octicon "pencil") words chars)
'face `(:family ,(all-the-icons-octicon-family) :inherit ,face)
'display '(raise -0.0))
(propertize (format " (%s, %s)" words chars)
'face `(:height 0.9 :inherit ,face))))))
(defun -custom-modeline-github-vc (face)
(let ((branch (mapconcat 'concat (cdr (split-string vc-mode "[:-]")) "-")))
(concat
(propertize (format " %s" (all-the-icons-alltheicon "git" :height 1.0 :v-adjust 0.1 :face face))
'display '(raise 0.1))
(propertize " • ")
(propertize (format "%s" (all-the-icons-octicon "git-branch" :face face))
'display '(raise 0.1))
(propertize (format " %s " branch)
'display '(raise 0.1) 'face `(:inherit ,face)))))
(defun custom-modeline-icon-vc (face)
(when vc-mode
(cond
((string-match "Git[:-]" vc-mode) (-custom-modeline-github-vc face))
(t (format "%s" vc-mode)))))
(defun xah-get-current-mode-str ()
(if xah-fly-insert-state-q "INSERT " "COMMAND ")))(use-package xah-fly-keys
:load-path "config"
:config
(xah-fly-keys 1)
(add-hook 'minibuffer-setup-hook
(lambda ()
(xah-fly-keys 0)))
(define-key xah-fly-key-map (kbd "C-M-c") 'buf-move-up)
(define-key xah-fly-key-map (kbd "C-M-t") 'buf-move-down)
(define-key xah-fly-key-map (kbd "C-M-h") 'buf-move-left)
(define-key xah-fly-key-map (kbd "C-M-n") 'buf-move-right)
)
(eval-and-compile
(defun my-keys-have-priority (_file)
"Try to ensure that my keybindings retain priority over other minor modes.
Called via the `after-load-functions' special hook."
(unless (eq (caar minor-mode-map-alist) 'xah-fly-keys)
(let ((mykeys (assq 'xah-fly-keys minor-mode-map-alist)))
(assq-delete-all 'xah-fly-keys minor-mode-map-alist)
(add-to-list 'minor-mode-map-alist mykeys))))
(add-hook 'after-load-functions 'my-keys-have-priority))(define-key xah-fly--tab-key-map (kbd "x") 'indent-xml)
(define-key xah-fly-e-keymap (kbd "k") 'paste-xml)
(define-key xah-fly-leader-key-map (kbd "f") 'helm-mini)
(define-key xah-fly-key-map (kbd "C-r") 'nil)
(define-key xah-fly-key-map (kbd "C-r") 'helm-projectile-find-file)
(define-key xah-fly-key-map (kbd "C-o") 'helm-find-files)
(define-key xah-fly-key-map (kbd "C-k") 'yank)
(define-key xah-fly-key-map (kbd "C-y") 'company-complete)
(global-set-key (kbd "<escape>") 'keyboard-escape-quit)
(defun quit-command()
(interactive)
(if xah-fly-insert-state-q
(xah-fly-command-mode-activate)
(if multiple-cursors-mode
(if (use-region-p)
(deactivate-mark))
(keyboard-quit))
))
(define-key xah-fly-key-map (kbd "<escape>") 'quit-command)(xah-fly--define-keys
(define-prefix-command 'kde-org-keymap)
'(
("a" . org-agenda)
("q" . org-archive-subtree)
("r" . org-refile)
("n" . org-add-note)
("p" . org-set-property)
("h" . hydra-org-clock-menu/body)
("c" . org-capture)
("o" . org-open-at-point)
("i" . org-toggle-inline-images)
("j" . (lambda () (interactive) (org-capture nil "j")))
))(xah-fly--define-keys
(define-prefix-command 'kde-git-keymap)
'(
("s" . magit-status)
("r" . magit-refresh)
("c" . magit-commit)
("p" . magit-push)
))(global-set-key (kbd "C-0") 'text-scale-increase)
(global-set-key (kbd "C-9") 'text-scale-decrease)
(define-key isearch-mode-map (kbd "<left>") 'isearch-ring-retreat )
(define-key isearch-mode-map (kbd "<right>") 'isearch-ring-advance )
(define-key isearch-mode-map (kbd "<up>") 'isearch-repeat-backward)
(define-key isearch-mode-map (kbd "<down>") 'isearch-repeat-forward)
(define-key minibuffer-local-isearch-map (kbd "<left>") 'isearch-reverse-exit-minibuffer)
(define-key minibuffer-local-isearch-map (kbd "<right>") 'isearch-forward-exit-minibuffer)
(global-set-key (kbd "C-c e") 'eval-and-replace)
(global-set-key (kbd "C-d") 'duplicate-line)
(global-set-key (kbd "C-l") 'goto-line)
(global-set-key (kbd "C-S-p") 'helm-projectile)
(global-set-key (kbd "C-S-f") 'helm-projectile-ag)(use-package nlinum
:defer t
:ensure t
:config
(progn
(setq nlinum-format " %3d ")
;; (add-hook 'prog-mode-hook 'nlinum-mode)
;; (add-hook 'text-mode-hook 'nlinum-mode)
))(use-package delight
:ensure t
:demand t)(use-package undo-tree
:defer t
:ensure t
:config
(global-undo-tree-mode 1))(use-package helm
:defer t
:ensure t
:config
(helm-mode)
(setq helm-split-window-in-side-p t)
;(setq helm-move-to-line-cycle-in-source t)
(setq helm-autoresize-max-height 0)
(setq helm-autoresize-min-height 40)
(define-key helm-map (kbd "<tab>") 'helm-execute-persistent-action)
(helm-autoresize-mode 1)
:bind (("C-f" . helm-occur)
:map helm-map
("M-c" . helm-previous-line)
("M-t" . helm-next-line)
:map xah-fly-key-map
("C-r" . helm-find-files)))
(use-package helm-descbinds
:ensure t
:config (helm-descbinds-mode))
(use-package helm-describe-modes
:ensure t
:config (global-set-key [remap describe-mode] #'helm-describe-modes))
(use-package which-key
:defer t
:ensure t
:config)(use-package multiple-cursors
:ensure t
:init
(global-set-key (kbd "C-8") 'mc/mark-all-like-this)
(global-set-key (kbd "M-8") 'vr/mc-mark)
;; :config
;; (define-key mc/keymap (kbd "<escape>") 'mc/keyboard-quit)
)(use-package company
:defer t
:config
(progn
(with-eval-after-load 'company
;; (company-quickhelp-mode)
;; (setq company-quickhelp-delay 1.0)
(define-key company-active-map (kbd "M-b") nil)
(define-key company-active-map (kbd "M-l") nil)
(define-key company-active-map (kbd "C-o") nil)
(define-key company-active-map (kbd "M-t") #'company-select-next)
(define-key company-active-map (kbd "M-c") #'company-select-previous)
(define-key company-active-map (kbd "M-f") #'company-search-candidates))
(global-set-key (kbd "C-y") 'company-complete)
(add-hook 'after-init-hook 'global-company-mode)
))(use-package expand-region
:defer t
:config
;; fix expand behavior in org-mode
(defun er--expand-region-1 ()
"Increase selected region by semantic units.
Basically it runs all the mark-functions in `er/try-expand-list'
and chooses the one that increases the size of the region while
moving point or mark as little as possible."
(let* ((p1 (point))
(p2 (if (use-region-p) (mark) (point)))
(start (min p1 p2))
(end (max p1 p2))
(try-list er/try-expand-list)
(best-start (point-min))
(best-end (point-max))
(set-mark-default-inactive nil))
;; add hook to clear history on buffer changes
(unless er/history
(add-hook 'after-change-functions 'er/clear-history t t))
;; remember the start and end points so we can contract later
;; unless we're already at maximum size
(unless (and (= start best-start)
(= end best-end))
(push (cons p1 p2) er/history))
(when (and expand-region-skip-whitespace
(er--point-is-surrounded-by-white-space)
(= start end))
(skip-chars-forward er--space-str)
(setq start (point)))
(while try-list
(org-save-outline-visibility t
(save-mark-and-excursion
(ignore-errors
(funcall (car try-list))
(when (and (region-active-p)
(er--this-expansion-is-better start end best-start best-end))
(setq best-start (point))
(setq best-end (mark))
(when (and er--show-expansion-message (not (minibufferp)))
(message "%S" (car try-list)))))))
(setq try-list (cdr try-list)))
(setq deactivate-mark nil)
;; if smart cursor enabled, decide to put it at start or end of region:
(if (and expand-region-smart-cursor
(not (= start best-start)))
(progn (goto-char best-end)
(set-mark best-start))
(goto-char best-start)
(set-mark best-end))
(er--copy-region-to-register)
(when (and (= best-start (point-min))
(= best-end (point-max))) ;; We didn't find anything new, so exit early
'early-exit)))
)
(use-package help-fns+
:ensure t
:disabled)(use-package smartparens
:defer t
:ensure t
:config
(add-hook 'python-mode-hook #'smartparens-mode)
(add-hook 'typescript-mode-hook #'smartparens-mode)
(add-hook 'org-mode-hook #'smartparens-mode))(use-package magit
:defer t
:ensure t
:bind (:map magit-file-section-map
("u" . nil)
("a" . nil)))(use-package yasnippet
:ensure t
:config
(setq yas-snippet-dirs '("~/.emacs.d/snippets"))
(yas-global-mode nil)
(define-key yas-keymap (kbd "C-d") 'yas-skip-and-clear-or-delete-char)
)(defmacro csetq (variable value)
`(funcall (or (get ',variable 'custom-set)
'set-default)
',variable ,value))
(csetq ediff-window-setup-function 'ediff-setup-windows-plain)
(csetq ediff-split-window-function 'split-window-horizontally)
(csetq ediff-diff-options "-w")
(defun ora-ediff-hook ()
(ediff-setup-keymap)
(define-key ediff-mode-map "t" 'ediff-next-difference)
(define-key ediff-mode-map "c" 'ediff-previous-difference))
(add-hook 'ediff-mode-hook 'ora-ediff-hook)
(add-hook 'ediff-after-quit-hook-internal 'winner-undo)(require 're-builder)
(setq reb-re-syntax 'string)
(use-package visual-regexp
:defer t
:ensure t)
(use-package visual-regexp-steroids
:defer t
:ensure t
:config
(setq vr/engine 'pcre2el))
(use-package pcre2el
:defer t
:ensure t)(defmacro diminish-major-mode (mode-hook abbrev)
`(add-hook ,mode-hook
(lambda () (setq mode-name ,abbrev))))
(use-package diminish
:demand t
:ensure t
:config
(progn
(diminish 'ivy-mode)
(diminish 'which-key-mode)
(diminish 'undo-tree-mode)
(diminish 'xah-fly-keys "xah")
(diminish 'all-the-icons-dired-mode)
(diminish-major-mode 'emacs-lisp-mode-hook "ξλ")
(diminish-major-mode 'lisp-interaction-mode-hook "λ")
))(use-package all-the-icons
:ensure t)(use-package dired
:defer t
:ensure nil
:bind (:map dired-mode-map
("C-<return>" . xah-open-in-external-app)
("RET" . dired-find-alternate-file)
("M-<return>" . kde-open-in-terminal))
:config
(add-hook 'dired-mode-hook 'dired-hide-details-mode))
(use-package tramp-hdfs
:defer t
:ensure t)
(use-package all-the-icons-dired
:after dired
:ensure t
:config
(add-hook 'dired-mode-hook 'all-the-icons-dired-mode))(use-package auto-highlight-symbol
:defer t
:ensure t
:config
(global-auto-highlight-symbol-mode t))
(use-package highlight-symbol
:defer t
:ensure t)(use-package google-translate
:defer t
:ensure t
:config
(setq google-translate-default-source-language "en")
(setq google-translate-default-target-language "ru"))
(use-package multitran
:defer t
:ensure t)
(defun multitran-custom ()
(interactive)
(multitran--word (thing-at-point 'word)))
(use-package key-chord
:defer t
:ensure t
:config
(key-chord-mode 1)
(key-chord-define xah-fly-key-map "``" 'custom-eval-double))(use-package flycheck
:defer t
:ensure t
:config
(global-flycheck-mode)
)
(use-package corral
:defer t
:ensure t)(use-package popwin
:defer t
:ensure t
:config
(popwin-mode 1)
(push "*multitran*" popwin:special-display-config))(use-package dumb-jump
:defer t
:ensure t)(use-package projectile
:defer t
:ensure t
:config
(projectile-global-mode)
(add-to-list 'projectile-globally-ignored-directories "node_modules"))
(xah-fly--define-keys
(define-prefix-command 'kde-projectile-keymap)
'(
("p" . helm-projectile)
("a" . helm-projectile-ag)
))
(use-package helm-projectile
:defer t
:ensure t)(use-package neotree
:ensure t
:config
(setq neo-theme (if (display-graphic-p) 'icons 'arrow))
(setq neo-smart-open t)
(setq projectile-switch-project-action 'neotree-projectile-action)
)(use-package editorconfig
:ensure t
:config
(editorconfig-mode 1))(use-package hydra
:ensure t)
(defhydra hydra-org-clock-menu (:color pink
:hint nil)
"
^Clock^
^^^^^^^^------
_c_: clock-in
_o_: clock-out
"
("c" org-clock-in)
("o" org-clock-out)
("q" nil "quit" :color blue)
)(use-package osx-dictionary
:ensure t)(use-package restclient
:ensure t)
(use-package ob-restclient
:ensure t)(use-package ob-http
:ensure t)(use-package anki-editor
:ensure t
:config
(setq anki-editor-create-decks t))(use-package org-mind-map
:init
(require 'ox-org)
:ensure t
;; Uncomment the below if 'ensure-system-packages` is installed
;;:ensure-system-package (gvgen . graphviz)
:config
(setq org-mind-map-engine "dot") ; Default. Directed Graph
;; (setq org-mind-map-engine "neato") ; Undirected Spring Graph
;; (setq org-mind-map-engine "twopi") ; Radial Layout
;; (setq org-mind-map-engine "fdp") ; Undirected Spring Force-Directed
;; (setq org-mind-map-engine "sfdp") ; Multiscale version of fdp for the layout of large graphs
;; (setq org-mind-map-engine "twopi") ; Radial layouts
;; (setq org-mind-map-engine "circo") ; Circular Layout
)(add-hook 'emacs-lisp-mode-hook 'turn-on-eldoc-mode)
(add-hook 'lisp-interaction-mode-hook 'turn-on-eldoc-mode)(use-package paredit
:defer t
:ensure t
:diminish paredit-mode
:init
(add-hook 'lisp-mode-hook 'enable-paredit-mode)
(add-hook 'emacs-lisp-mode-hook 'enable-paredit-mode)
(add-hook 'lisp-interaction-mode-hook 'enable-paredit-mode)
:bind (:map paredit-mode-map
(";" . nil)
(":" . nil)
("C-d" . nil)
("M-;" . nil))
:config
(define-key paredit-mode-map (kbd "C-,") 'paredit-wrap-round)
(define-key paredit-mode-map (kbd "C-<") 'paredit-forward-barf-sexp)
(define-key paredit-mode-map (kbd "C->") 'paredit-forward-slurp-sexp)
(define-key paredit-mode-map (kbd "C-p") 'paredit-raise-sexp)
(define-key paredit-mode-map (kbd "C-S-r") 'paredit-forward)
(define-key paredit-mode-map (kbd "C-S-g") 'paredit-backward)
;; (define-key paredit-mode-map (kbd "C-S-t") 'paredit-forward-up)
;; (define-key paredit-mode-map (kbd "C-S-c") 'paredit-backward-up)
(define-key paredit-mode-map (kbd "C-<return>") 'paredit-close-new-line-custom)
(defun paredit-close-new-line-custom ()
(interactive)
(paredit-close-round)
(newline-and-indent)))(with-eval-after-load 'nxml-mode
(define-key nxml-mode-map (kbd "C-S-g") 'my-hs-hide-level)
(define-key nxml-mode-map (kbd "C-S-r") 'my-hs-toggle-hiding)
(define-key nxml-mode-map (kbd "C-0") 'hs-show-all))
(add-to-list 'hs-special-modes-alist
'(nxml-mode
"<!--\\|<[^/>]*[^/]>"
"-->\\|</[^/>]*[^/]>"
"<!--"
sgml-skip-tag-forward
nil))
(add-hook 'nxml-mode-hook 'hs-minor-mode)
(defun custom-folding ()
(interactive)
(save-excursion
(end-of-line)
(hs-toggle-hiding)))
(defun indent-xml()
(interactive)
(goto-char (point-min))
(while (re-search-forward "><" nil t)
(replace-match ">\n<"))
(nxml-mode)
(indent-region (point-min) (point-max) nil)
(goto-char (point-min)))
(global-set-key (kbd "M-<f12>") 'indent-xml)
(defun paste-xml ()
(interactive)
(large-file-mode)
(xah-paste-or-paste-previous)
(indent-xml))(define-fringe-bitmap 'hs-marker [0 24 24 126 126 24 24 0])
(defcustom hs-fringe-face 'hs-fringe-face
"*Specify face used to highlight the fringe on hidden regions."
:type 'face
:group 'hideshow)
(defface hs-fringe-face
'((t (:foreground "#888" :box (:line-width 2 :color "grey75" :style released-button))))
"Face used to highlight the fringe on folded regions"
:group 'hideshow)
(defcustom hs-face 'hs-face
"*Specify the face to to use for the hidden region indicator."
:type 'face
:group 'hideshow)
(defface hs-face
'((t (:background "#93a1a1" :foreground "#002b36" :box t)))
"Face to hightlight the ... area of hidden regions"
:group 'hideshow)
(defun display-code-line-counts (ov)
(when (eq 'code (overlay-get ov 'hs))
(let* ((marker-string "*fringe-dummy*")
(marker-length (length marker-string))
(display-string (format "(%d)..." (count-lines (overlay-start ov) (overlay-end ov))))
)
;; On hover over the overlay display the hidden text.
(overlay-put ov 'help-echo (buffer-substring (overlay-start ov)
(overlay-end ov)))
(put-text-property 0 marker-length 'display (list 'left-fringe 'hs-marker 'hs-fringe-face) marker-string)
(overlay-put ov 'before-string marker-string)
(put-text-property 0 (length display-string) 'face 'hs-face display-string)
(overlay-put ov 'display display-string)
)))
(setq hs-set-up-overlay 'display-code-line-counts)(defun my-hs-toggle-hiding (arg)
(interactive "p")
(save-excursion (hs-toggle-hiding)))
(defun my-hs-hide-level (arg)
(interactive "p")
(hs-hide-level 1));; Large file performance improvement
(setq line-number-display-limit large-file-warning-threshold)
(setq line-number-display-limit-width 200)
(defun my--is-file-large ()
"If buffer too large and my cause performance issue."
(< large-file-warning-threshold (buffer-size)))
(define-derived-mode large-file-mode fundamental-mode "LargeFile"
"Fixes performance issues in Emacs for large files."
;; (setq buffer-read-only t)
(setq bidi-display-reordering nil)
(jit-lock-mode nil)
;; (buffer-disable-undo)
(set (make-variable-buffer-local 'global-hl-line-mode) nil)
(set (make-variable-buffer-local 'line-number-mode) nil)
(set (make-variable-buffer-local 'column-number-mode) nil))
(add-to-list 'magic-mode-alist (cons #'my--is-file-large #'large-file-mode))
(defadvice xah-paste-or-paste-previous (before large-file-paste activate)
(large-file-paste))
(defun large-file-paste ()
(interactive)
(let (text len)
(setq text (car kill-ring))
(setq len (length text))
(message "length %d" len)
(if (> len 10000)
(large-file-mode))))(use-package elpy
:defer t
:config
(elpy-enable)
;; (setq Exec-path (append exec-path '("c:/Program Files (x86)/Python3/Scripts")))
;;(setq Exec-path (append exec-path '("c:/Users/Yauheni_Kuzmianok/.virtualenv/Scripts")))
;;(pyvenv-activate "~/.virtualenv")
;; (elpy-use-ipython)
;; (setq python-shell-interpreter "ipython3"
;; python-shell-interpreter-args "--simple-prompt -i")
;; (setenv "PYTHONIOENCODING" "UTF-8")
(setq elpy-rpc-backend "jedi")
(setq elpy-rpc-python-command "python3")
(setq elpy-rpc-py "jedi")
(setq jedi:complete-on-dot t)
;; (setq jedi:setup-keys t)
)
(use-package realgud
:defer t)
(require 'cl)
(use-package ein
:defer t
:config
(progn
(require 'websocket)
;; Use Jedi with EIN
(add-hook 'ein:connect-mode-hook 'ein:jedi-setup)
(setq ein:default-url-or-port "http://localhost:8888"
ein:output-type-preference '(emacs-lisp svg png jpeg
html text latex javascript))
)
)
(use-package virtualenvwrapper
:defer t
:config
(venv-initialize-interactive-shells)
(venv-initialize-eshell)
(setq venv-location "~/.virtualenv/"))
(defun prelude-personal-python-mode-defaults ()
"Personal defaults for Python programming."
;; Enable elpy mode
(elpy-mode)
(smartparens-mode)
;; Jedi backend
;; (jedi:setup)
;; (setq jedi:complete-on-dot t) ;optional
;; (auto-complete-mode)
;; (jedi:ac-setup)
;; (setq elpy-rpc-python-command "python3")
;; (python-shell-interpreter "ipython3")
)
(setq prelude-personal-python-mode-hook 'prelude-personal-python-mode-defaults)
(add-hook 'python-mode-hook (lambda ()
;(electric-pair-mode 1)
(run-hooks 'prelude-personal-python-mode-hook)))
(defun my/python-mode-hook ()
(add-to-list 'company-backends 'company-jedi))
(use-package ob-ipython
:defer t
:ensure t
:config
(setq org-confirm-babel-evaluate nil)
(add-hook 'org-babel-after-execute-hook 'org-display-inline-images 'append)
(setq org-startup-with-inline-images t))(use-package org
:defer t
:mode ("\\.txt\\'" . org-mode)
:init
(require 'org-protocol)
(add-hook 'org-mode-hook
(lambda ()
(progn
(org-bullets-mode t)
(define-key org-mode-map (kbd "C-j") 'org-metaleft)
(define-key org-mode-map (kbd "C-l") 'org-metaright)
(setq org-file-apps (append
'( ("\\.jpg\\'" . default)
("\\.png\\'" . default))
org-file-apps ) ))))
:config
(org-babel-do-load-languages
'org-babel-load-languages
'((lisp . t)
(emacs-lisp . t)
(python . t)
(shell . t)
(js . t)
(restclient . t)
(ruby . t)
(http . t)
(dot . t)))
(setq org-src-tab-acts-natively t)
(setq org-agenda-files '("~/Dropbox/org"))
(setq org-log-done 'time)
(setq org-src-fontify-natively t)
(setq org-edit-src-content-indentation 0)
(setq org-ellipsis " ↴")
(setq org-refile-targets
'(("personal.org" :maxlevel . 1)
("work.org" :maxlevel . 1)
("people.org" :maxlevel . 1)
("music.org" :maxlevel . 1)
("routine.org" :maxlevel . 1)
("auto.org" :maxlevel . 1)
("Ania.org" :maxlevel . 1)
("games.org" :maxlevel . 1)
("true.org" :maxlevel . 1)
("rabbits.org" :maxlevel . 1)
("issues.org" :maxlevel . 1)
("movie.org" :maxlevel . 1)
("quotes.org" :maxlevel . 1)
("true.org" :maxlevel . 1)
("japanese.org" :maxlevel . 1)
))
(setq org-agenda-custom-commands
'(("w" "Work"
((agenda "" ((org-agenda-files '("~/Dropbox/org/work.org"))))
(alltodo "" ((org-agenda-overriding-header "Work todo items")(org-agenda-files '("~/Dropbox/org/work.org")))))
)
))
(setq org-src-window-setup 'current-window)
(add-to-list 'org-structure-template-alist
'("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC"))
(org-add-link-type "karabiner" 'open-pdf-from-library
(lambda (path desc format)
(format "[%s](%s:%s)" desc "karabiner" path)))
(defun jira-ext (jira)
(browse-url (concat jira-path (car (cdr (split-string jira "-"))))))
(org-add-link-type "jira" 'jira-ext)
(add-to-list 'helm-completing-read-handlers-alist '(org-capture . aj/org-completing-read-tags))
(add-to-list 'helm-completing-read-handlers-alist '(org-set-tags . aj/org-completing-read-tags))
(setq org-capture-templates
'(("t" "Todo" entry (file "~/Dropbox/org/Inbox.org")
"* TODO %?\n %i\n %a")
("n" "Note" entry (file "~/Dropbox/org/Inbox.org")
"* %?\n %i\n")
("j" "Journal" entry (file+olp+datetree "~/Dropbox/org/journal.org")
"** %a :%(my/expense-template):\n- %i%?\n%U")
("p" "Protocol" entry (file "~/Dropbox/org/Inbox.org")
"* %? [[%:link][%:description]] \n%i\n%c\n" :immediate-finish t)
("w" "Protocol" entry (file "~/Dropbox/org/Inbox.org")
"* %? [[%:link][%:description]] \n%i\n" :immediate-finish t)
))
(require 'org-agenda)
(defun org-agenda-get-progress ()
"Return the logged TODO entries for agenda display."
(let* ((props (list 'mouse-face 'highlight
'org-not-done-regexp org-not-done-regexp
'org-todo-regexp org-todo-regexp
'org-complex-heading-regexp org-complex-heading-regexp
'help-echo
(format "mouse-2 or RET jump to org file %s"
(abbreviate-file-name buffer-file-name))))
(items (if (consp org-agenda-show-log-scoped)
org-agenda-show-log-scoped
(if (eq org-agenda-show-log-scoped 'clockcheck)
'(clock)
org-agenda-log-mode-items)))
(parts
(delq nil
(list
(if (memq 'closed items) (concat "\\<" org-closed-string))
(if (memq 'clock items) (concat "\\<" org-clock-string))
(if (memq 'state items)
(format "- State \"%s\".*?" org-todo-regexp))
"- Note .*?")))
(parts-re (if parts (mapconcat 'identity parts "\\|")
(error "`org-agenda-log-mode-items' is empty")))
(regexp (concat
"\\(" parts-re "\\)"
" *\\["
(regexp-quote
(substring
(format-time-string
(car org-time-stamp-formats)
(apply 'encode-time ; DATE bound by calendar
(list 0 0 0 (nth 1 date) (car date) (nth 2 date))))
1 11))))
(org-agenda-search-headline-for-time nil)
marker hdmarker priority category level tags closedp notep
statep clockp state ee txt extra timestr rest clocked inherited-tags)
(goto-char (point-min))
(while (re-search-forward regexp nil t)
(catch :skip
(org-agenda-skip)
(message "%s" "test124")
(message "%s" (match-string 1))
(setq marker (org-agenda-new-marker (match-beginning 0))
closedp (equal (match-string 1) org-closed-string)
notep (string-match-p "Note" (match-string 1))
statep (equal (string-to-char (match-string 1)) ?-)
clockp (not (or closedp statep))
state (and statep (match-string 2))
category (org-get-category (match-beginning 0))
timestr (buffer-substring (match-beginning 0) (point-at-eol)))
(when (string-match "\\]" timestr)
;; substring should only run to end of time stamp
(setq rest (substring timestr (match-end 0))
timestr (substring timestr 0 (match-end 0)))
(if (and (not closedp) (not statep)
(string-match "\\([0-9]\\{1,2\\}:[0-9]\\{2\\}\\)\\].*?\\([0-9]\\{1,2\\}:[0-9]\\{2\\}\\)"
rest))
(progn (setq timestr (concat (substring timestr 0 -1)
"-" (match-string 1 rest) "]"))
(setq clocked (match-string 2 rest)))
(setq clocked "-")))
(save-excursion
(setq extra
(cond
((not org-agenda-log-mode-add-notes) nil)
(statep
(and (looking-at ".*\\\\\n[ \t]*\\([^-\n \t].*?\\)[ \t]*$")
(match-string 1)))
(clockp
(and (looking-at ".*\n[ \t]*-[ \t]+\\([^-\n \t].*?\\)[ \t]*$")
(match-string 1)))))
(message "%s" (concat "- test " extra))
(if (not (re-search-backward org-outline-regexp-bol nil t))
(throw :skip nil)
(goto-char (match-beginning 0))
(setq hdmarker (org-agenda-new-marker)
inherited-tags
(or (eq org-agenda-show-inherited-tags 'always)
(and (listp org-agenda-show-inherited-tags)
(memq 'todo org-agenda-show-inherited-tags))
(and (eq org-agenda-show-inherited-tags t)
(or (eq org-agenda-use-tag-inheritance t)
(memq 'todo org-agenda-use-tag-inheritance))))
tags (org-get-tags-at nil (not inherited-tags))
level (make-string (org-reduced-level (org-outline-level)) ? ))
(looking-at "\\*+[ \t]+\\([^\r\n]+\\)")
(setq txt (match-string 1))
(when extra
(if (string-match "\\([ \t]+\\)\\(:[^ \n\t]*?:\\)[ \t]*$" txt)
(setq txt (concat (substring txt 0 (match-beginning 1))
" - " extra " " (match-string 2 txt)))
(setq txt (concat txt " - " extra))))
(setq txt (org-agenda-format-item
(cond
(closedp "Closed: ")
(notep "Note: ")
(statep (concat "State: (" state ")"))
(t (concat "Clocked: (" clocked ")")))
txt level category tags timestr)))
(setq priority 100000)
(org-add-props txt props
'org-marker marker 'org-hd-marker hdmarker 'face 'org-agenda-done
'priority priority 'level level
'type "closed" 'date date
'undone-face 'org-warning 'done-face 'org-agenda-done)
(push txt ee))
(goto-char (point-at-eol))))
(nreverse ee)))
)
(use-package org-bullets
:ensure t)
(defun my/expense-template ()
(file-name-sans-extension (plist-get org-capture-plist :original-file-nondirectory)))
(defun aj/org-completing-read-tags (prompt coll pred req initial hist def inh)
(if (not (string= "Tags: " prompt))
;; Not a tags prompt. Use normal completion by calling
;; `org-icompleting-read' again without this function in
;; `helm-completing-read-handlers-alist'
(let ((helm-completing-read-handlers-alist (rassq-delete-all
'aj/org-completing-read-tags
helm-completing-read-handlers-alist)))
(org-icompleting-read prompt coll pred req initial hist def inh))
;; Tags prompt
(let* ((initial (and (stringp initial)
(not (string= initial ""))
initial))
(curr (when initial
(org-split-string initial ":")))
(table (org-uniquify
(mapcar 'car org-last-tags-completion-table)))
(table (if curr
;; Remove current tags from list
(cl-delete-if (lambda (x)
(member x curr))
table)
table))
(prompt (if initial
(concat "Tags " initial)
prompt)))
(concat initial (mapconcat 'identity
(nreverse (aj/helm-completing-read-multiple
prompt table pred nil nil hist def
t "Org tags" "*Helm org tags*" ":"))
":")))))
(defun aj/helm-completing-read-multiple (prompt choices
&optional predicate require-match initial-input hist def
inherit-input-method name buffer sentinel)
"Read multiple items with `helm-completing-read-default-1'. Reading stops
when the user enters SENTINEL. By default, SENTINEL is
\"*done*\". SENTINEL is disambiguated with clashing completions
by appending _ to SENTINEL until it becomes unique. So if there
are multiple values that look like SENTINEL, the one with the
most _ at the end is the actual sentinel value. See
documentation for `ido-completing-read' for details on the
other parameters."
(let ((sentinel (or sentinel "*done*"))
this-choice res done-reading)
;; Uniquify the SENTINEL value
(while (cl-find sentinel choices)
(setq sentinel (concat sentinel "_")))
(setq choices (cons sentinel choices))
;; Read choices
(while (not done-reading)
(setq this-choice (helm-completing-read-default-1 prompt choices
predicate require-match initial-input hist def
inherit-input-method name buffer nil t))
(if (equal this-choice sentinel)
(setq done-reading t)
(setq res (cons this-choice res))
(setq prompt (concat prompt this-choice ":"))))
res))
(require 'eldoc)
(defun org-get-description-at-point ()
(interactive)
(org-element-property :DESCRIPTION (org-element-at-point)))
(defun org-eldoc-get-breadcrumb ()
"Return breadcrumb if on a headline or nil."
(let ((case-fold-search t) cur)
(save-excursion
(beginning-of-line)
(save-match-data
(when (looking-at org-complex-heading-regexp)
(setq cur (match-string 4))
(concat (org-format-outline-path
(append (org-get-outline-path) (list cur))
(frame-width) "" "/") " - ["(org-get-description-at-point) "]"))))))
(defun org-eldoc-documentation-function ()
"Return breadcrumbs when on a headline, args for src block header-line,
calls other documentation functions depending on lang when inside src body."
(or
(org-eldoc-get-breadcrumb)))
(defun org-eldoc-load ()
"Set up org-eldoc documentation function."
(interactive)
(setq-local eldoc-documentation-function #'org-eldoc-documentation-function))
(add-hook 'org-mode-hook #'org-eldoc-load)
(defun make-orgcapture-frame ()
"Create a new frame and run org-capture."
(interactive)
(make-frame '((name . "remember") (width . 80) (height . 16)
(top . 400) (left . 300)
))
(select-frame-by-name "remember")
(org-capture))
(use-package ox-hugo
:defer t
:after ox)
(use-package org-super-agenda
:ensure t
:defer t
:config
(org-super-agenda-mode t))
(use-package org-download
:ensure t
:config
(setq-default org-download-image-dir "~/Dropbox/org/images")
(setq org-image-actual-width nil))
(use-package web-mode
:defer t
:ensure t
:config
(add-hook 'web-mode-hook 'smartparens-mode)
(sp-with-modes '(web-mode)
(sp-local-pair "{% " " %}")
(sp-local-pair "<p> " " </p>")
(sp-local-pair "{% " " %}")
(sp-local-pair "{{ " " }}")
(sp-local-tag "%" "<% " " %>")
(sp-local-tag "=" "<%= " " %>")
(sp-local-tag "#" "<%# " " %>")))
(use-package emmet-mode
:defer t
:ensure t
:config
(add-hook 'web-mode-hook 'emmet-mode)
(add-hook 'html-mode-hook 'emmet-mode))
(use-package rainbow-mode
:defer t
:ensure t
:config
(add-hook 'html-mode-hook 'rainbow-mode)
(add-hook 'css-mode-hook 'rainbow-mode))(use-package js2-mode
:defer t
:ensure t
:mode ("\\.js\\'" . js2-mode)
:hook ((js2-mode . tern-mode)
(js2-mode . company-mode)
))
(use-package tern
:ensure t)
(use-package company-tern
:ensure t
:config
(add-to-list 'company-backends 'company-tern))
;; (defun setup-tide-mode ()
;; (interactive)
;; (tide-setup)
;; (flycheck-mode +1)
;; (setq flycheck-check-syntax-automatically '(save mode-enabled))
;; (eldoc-mode +1)
;; (tide-hl-identifier-mode +1)
;; ;; company is an optional dependency. You have to
;; ;; install it separately via package-install
;; ;; `M-x package-install [ret] company`
;; (company-mode +1))
;; (use-package tide
;; :defer t
;; :ensure t)
;; formats the buffer before saving
;; (add-hook 'before-save-hook 'tide-format-before-save)
;; (add-hook 'typescript-mode-hook #'setup-tide-mode)
(use-package skewer-mode
:defer t
:ensure t
:config
(add-hook 'html-mode-hook 'skewer-html-mode)
(add-hook 'js2-mode 'skewer-mode)
(add-hook 'css-mode 'skewer-mode)
(define-key html-mode-map (kbd "C-c C-c") 'skewer-html-eval-tag))(setq insert-directory-program "gls")
(setq dired-use-ls-dired t)
(setq dired-listing-switches "-al --group-directories-first")(use-package clojure-mode
:defer t
:hook ((clojure-mode . cider-mode)
(clojure-mode . enable-paredit-mode)))
(use-package cider
:defer t
:hook ((cider-mode . company-mode)
(cider-repl-mode . company-mode)))(use-package pdf-tools
:ensure t)
(use-package org-pdfview
:ensure t)
(defun generate-interest-org-data ()
(interactive)
(with-current-buffer (find-file-noselect "~/Dropbox/org/journal.org")
(let ((parsetree (org-element-parse-buffer 'headline)))
(org-element-map parsetree 'headline
(lambda (hl)
(let ((data (org-element-property :title hl))
(interest (org-element-property :INTEREST hl)))
(if (not (equal interest nil))
(list (cons "data" data) (cons "interest" interest))))
)))))