;; This file replaces itself with the actual configuration at first run.
;; We can't tangle without org!
(require 'org)
;; Open the configuration
(find-file (concat user-emacs-directory "init.org"))
;; tangle it
(org-babel-tangle)
;; load it
(load-file (concat user-emacs-directory "init.el"))
;; finally byte-compile it
(byte-compile-file (concat user-emacs-directory "init.el"))(require 'package)
(unless (assoc-default "melpa" package-archives)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t))
(package-initialize)https://github.com/jwiegley/use-package/blob/master/README.md
(unless (package-installed-p 'use-package)
(package-refresh-contents)
(package-install 'use-package))
(eval-when-compile
(require 'use-package))
(require 'bind-key) ;; if you use any :bind variant
(setq use-package-always-ensure t)
;; Enable ensure-system-package keyword
(use-package use-package-ensure-system-package)
;; Auto-install missing system packages
(use-package system-packages)(add-to-list 'default-frame-alist '(height . 47))
(add-to-list 'default-frame-alist '(width . 110))
(prefer-coding-system 'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
;; (set-fontset-font "fontset-default" '(#x1d4d0 . #x1d4e2) "Symbola")
;; Use DejaVu Sans Mono as a fallback in fontset-startup
;; before resorting to fontset-default.
(set-fontset-font "fontset-startup" nil "DejaVu Sans Mono" nil 'append)
(when (member "Meslo LG M for Powerline" (font-family-list))
(set-frame-font "Meslo LG M for Powerline 13" t t))(scroll-bar-mode -1)
(tool-bar-mode -1)
(setq ring-bell-function 'ignore)
(setq inhibit-startup-screen t)
(fset 'yes-or-no-p 'y-or-n-p)(global-unset-key (kbd "<M-drag-mouse-1>")) ; was mouse-set-secondary (global-unset-key (kbd "<M-down-mouse-1>")) ; was mouse-drag-secondary (global-unset-key (kbd "<M-mouse-1>")) ; was mouse-start-secondary (global-unset-key (kbd "<M-mouse-2>")) ; was mouse-yank-secondary (global-unset-key (kbd "<M-mouse-3>")) ; was mouse-secondary-save-then-kill
(setq-default
display-time 1
display-time-24hr-format t
display-time-day-and-date nil
display-time-default-load-average nil
battery−mode−line−format " [%L %p%% %dC]")
(display-time-mode)(setq auto-save-file-name-transforms
`((".*" ,temporary-file-directory t))
save-place-file (concat user-emacs-directory "places")
backup-directory-alist `(("." . ,(concat user-emacs-directory "backups"))))
(setq backup-by-copying t)
(setq delete-old-versions t
kept-new-versions 6
kept-old-versions 2
version-control t)(setq
x-select-enable-clipboard t
x-select-enable-primary t)Make all buffers have unique names
(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)(line-number-mode t)
(column-number-mode t)
;(size-indication-mode t)(setq mac-command-modifier 'meta)
(setq mac-option-modifier nil)
(setq locate-command "mdfind")
(setq ns-pop-up-frames nil)
;; Some mac-bindings interfere with Emacs bindings.
(when (boundp 'mac-pass-command-to-system)
(setq browse-url-browser-function 'browse-url-default-macosx-browser)
(setq mac-pass-command-to-system nil))(setq next-screen-context-lines 8)(global-set-key (kbd "C-x k") 'kill-this-buffer)
(global-set-key (kbd "C-x C-b") 'bury-buffer)
(set-language-environment "UTF-8")
(set-default-coding-systems 'utf-8)
(add-hook 'text-mode-hook 'flyspell-mode)
;;(add-hook 'prog-mode-hook 'flyspell-prog-mode)
(setq flyspell-issue-message-flag nil)
(setq tramp-default-method "ssh")
(setq explicit-shell-file-name "/bin/bash")
(setq-default indent-tabs-mode nil)
(setq-default fill-column 120)
(setq-default sentence-end-double-space nil)
(setq paragraph-start "\f\\|[ \t]*$\\|[ \t]*[-+*] ")
(add-to-list 'ignored-local-variables 'preview-scale-function)
(setq custom-safe-themes t)
(show-paren-mode)
(setq show-paren-style 'expression)
(setq recenter-positions '(middle top bottom))
(remove-hook 'text-mode-hook 'turn-on-auto-fill)
(add-hook 'mu4e-compose-mode-hook 'turn-off-auto-fill)
;;(setq browse-url-browser-function 'eww-browse-url);; Set $DICPATH to "$HOME/Library/Spelling" for hunspell.
;; (setenv
;; "DICPATH"
;; (concat (getenv "HOME") "/Library/Spelling"))
;; Tell ispell-mode to use hunspell.
(setq ispell-local-dictionary-alist '(("dansk"
"[[:alpha:]]"
"[^[:alpha:]]"
"[']"
t
("-d" "da_DK"); Dictionary file name
nil
iso-8859-1)
("american"
"[[:alpha:]]"
"[^[:alpha:]]"
"[']"
t
("-d" "en_US") ; Dictionary file name
nil
iso-8859-1)))
(setq ispell-dictionary "american")
(setq
ispell-program-name
"/usr/local/bin/hunspell")Add bullets to comment blocks
(setq paragraph-start "\f\\|[ \t]*$\\|[ \t]*[-+*] ")Fix comment-dwim such that whole line is (un)commented when no region is active
(defun xah-comment-dwim ()
"Like `comment-dwim', but toggle comment if cursor is not at end of line.
URL `http://ergoemacs.org/emacs/emacs_toggle_comment_by_line.html'
Version 2016-10-25"
(interactive)
(if (region-active-p)
(comment-dwim nil)
(let ((-lbp (line-beginning-position))
(-lep (line-end-position)))
(if (eq -lbp -lep)
(progn
(comment-dwim nil))
(if (eq (point) -lep)
(progn
(comment-dwim nil))
(progn
(comment-or-uncomment-region -lbp -lep)
(forward-line )))))))
(global-set-key (kbd "M-;") 'xah-comment-dwim)
(global-set-key (kbd "C-æ") 'xah-comment-dwim)(use-package hydra
:bind*
(
("C-M-k" . hydra-pause-resume)
("C-c C-h" . hydra-proof-general/body)
("C-x o" . hydra-window/body)
("C-c C-m" . hydra-multiple-cursors/body)
("C-c T" . hydra-toggle-simple/body)
;; ("C-x SPC" . hydra-rectangle/body)
("C-c h" . hydra-apropos/body)
:map Buffer-menu-mode-map
("h" . hydra-buffer-menu/body)
:map org-mode-map
)
:config
(defhydra hydra-zoom (global-map "<f2>")
"zoom"
("g" text-scale-increase "in")
("l" text-scale-decrease "out"))
;; (require 'hydra-examples)
(defhydra hydra-toggle-simple (:color blue)
"toggle"
("a" abbrev-mode "abbrev")
("d" toggle-debug-on-error "debug")
("f" auto-fill-mode "fill")
("t" toggle-truncate-lines "truncate")
("w" whitespace-mode "whitespace")
("q" nil "cancel"))
(defhydra hydra-window (:color red
:hint nil)
"
Split: _v_ert _x_:horz
Delete: _o_nly _da_ce _dw_indow _db_uffer _df_rame
Move: _s_wap
Frames: _f_rame new _df_ delete
Misc: _m_ark _a_ce _u_ndo _r_edo"
("h" windmove-left)
("j" windmove-down)
("k" windmove-up)
("l" windmove-right)
("H" hydra-move-splitter-left)
("J" hydra-move-splitter-down)
("K" hydra-move-splitter-up)
("L" hydra-move-splitter-right)
("|" (lambda ()
(interactive)
(split-window-right)
(windmove-right)))
("_" (lambda ()
(interactive)
(split-window-below)
(windmove-down)))
("v" split-window-right)
("x" split-window-below)
;("t" transpose-frame "'")
;; winner-mode must be enabled
("u" winner-undo)
("r" winner-redo) ;;Fixme, not working?
("o" delete-other-windows :exit t)
("a" ace-window :exit t)
("f" new-frame :exit t)
("s" ace-swap-window)
("da" ace-delete-window)
("dw" delete-window)
("db" kill-this-buffer)
("df" delete-frame :exit t)
("q" nil)
;("i" ace-maximize-window "ace-one" :color blue)
;("b" ido-switch-buffer "buf")
("m" headlong-bookmark-jump))
(require 'multiple-cursors)
(defhydra hydra-multiple-cursors (:hint nil)
"
Up^^ Down^^ Miscellaneous % 2(mc/num-cursors) cursor%s(if (> (mc/num-cursors) 1) \"s\" \"\")
------------------------------------------------------------------
[_p_] Next [_n_] Next [_l_] Edit lines [_0_] Insert numbers
[_P_] Skip [_N_] Skip [_a_] Mark all [_A_] Insert letters
[_M-p_] Unmark [_M-n_] Unmark [_s_] Search
[Click] Cursor at point [_q_] Quit"
("l" mc/edit-lines :exit t)
("a" mc/mark-all-like-this :exit t)
("n" mc/mark-next-like-this)
("N" mc/skip-to-next-like-this)
("M-n" mc/unmark-next-like-this)
("p" mc/mark-previous-like-this)
("P" mc/skip-to-previous-like-this)
("M-p" mc/unmark-previous-like-this)
("s" mc/mark-all-in-region-regexp :exit t)
("0" mc/insert-numbers :exit t)
("A" mc/insert-letters :exit t)
("<mouse-1>" mc/add-cursor-on-click)
;; Help with click recognition in this hydra
("<down-mouse-1>" ignore)
("<drag-mouse-1>" ignore)
("q" nil))
)(use-package org
:diminish visual-line-mode org-cdlatex-mode org-indent-mode
:ensure org-plus-contrib
:mode (("\\.\\(org\\|org_archive\\|txt\\)$" . org-mode))
:bind* (
("C-c l" . org-store-link)
("C-c c" . org-capture)
("C-c a" . org-agenda)
("C-c b" . org-iswitchb)
("C-'" . org-cycle-agenda-files)
:map org-mode-map
("<f8>" . org-toggle-latex-fragment)
("C-M-o" . ace-link-org)
)
:config
;; (add-hook 'org-mode-hook 'worf-mode)
(add-to-list 'org-speed-commands-user '("a" . org-attach))
(require 'org-tempo)
(load (concat user-emacs-directory "ob-troupe.el"))
(require 'ob-troupe)
(setq org-use-speed-commands t)
(add-hook 'org-mode-hook 'visual-line-mode)
(add-hook 'org-mode-hook 'add-pcomplete-to-capf)
(plist-put org-format-latex-options :scale 1.6)
(setq org-fontify-whole-heading-line t)
(setq org-hide-leading-stars t)
(setq org-src-fontify-natively t)
(setq org-src-preserve-indentation t)
(org-babel-do-load-languages
'org-babel-load-languages
'((calc . t)
(dot . t)
(ditaa . t)
;; (sh . t)
(shell . t)
(troupe . t)
(latex . t)))
(add-to-list 'org-src-lang-modes '("troupe" . "sml"))
(add-to-list 'org-src-lang-modes '("dot" . graphviz-dot))
)(use-package crux
:bind* (("C-c o" . crux-open-with)
;; ("C-c e" . crux-eval-and-replace)
("C-c t" . eshell)
("C-^" . crux-top-join-line)
("C-c d" . crux-duplicate-current-line-or-region)
("C-a" . crux-move-beginning-of-line))
:bind (
("M-O" . crux-smart-open-line-above)
("M-o" . crux-smart-open-line)
)
:config
(setq pcomplete-ignore-case t))(use-package undo-tree
:diminish undo-tree-mode
:bind (("C-x u" . undo-tree-visualize)
("C--" . undo))
:config
(global-undo-tree-mode))(use-package autorevert
:diminish auto-revert-mode
:config
(global-auto-revert-mode 1))(use-package discover-my-major
:bind ("C-h C-m" . discover-my-major))(use-package popwin
:config
(global-set-key (kbd "C-z") popwin:keymap)
(setq popwin:special-display-config
'((completion-list-mode :noselect t)
(compilation-mode :noselect t)
(grep-mode :noselect t)
(occur-mode :noselect t)
("*Swoop*" :height 0.5 :position bottom)
("\*.* output\*" :regexp t :height 0.5 :noselect t :position bottom)
("*Warnings*" :height 0.5 :noselect t)
("*TeX Help*" :height 0.5 :noselect t)
("*ENSIME Welcome*" :height 0.5 :noselect t)
("\*sbt\*" :regexp t :height 0.2 :position bottom)
("*Procces List*" :height 0.5)
("*Python Doc*" :height 0.5 :noselect t)
("*Messages*" :height 0.5 :noselect t)
("*Help*" :height 0.5 :noselect nil)
("*Backtrace*" :height 0.5)
("*Compile-Log*" :height 0.5 :noselect t)
("*Remember*" :height 0.5)
("*ansi-term*" :height 0.5 :position top)
("*All*" :height 0.5)
("*Go Test*" :height 0.3)
("*undo-tree*" :width 0.3 :position right)
("*Slack -" :regexp t :height 0.5 :position bottom)
(flycheck-error-list-mode :height 0.5 :regexp t :position bottom)))
(popwin-mode t))(use-package magit
:bind (("C-x g" . magit-status)))(use-package diff-hl
:config
(add-hook 'magit-post-refresh-hook 'diff-hl-magit-post-refresh)
(global-diff-hl-mode))(use-package exec-path-from-shell
:config
(exec-path-from-shell-initialize)
(setq exec-path-from-shell-check-startup-files nil)
(exec-path-from-shell-copy-envs '("GPG_AGENT_INFO" "LC_ALL" "LC_CTYPE" "SSH_AUTH_SOCK")))(use-package opam
:config
(opam-init))(use-package smex)(use-package company
:diminish company-mode
:init
;; https://github.com/company-mode/company-mode/issues/50#issuecomment-33338334
(defun add-pcomplete-to-capf ()
(add-hook 'completion-at-point-functions 'pcomplete-completions-at-point nil t))
:bind*
(("C-M-i" . company-complete)
:map company-active-map
("C-n" . company-select-next)
("C-p" . company-select-previous))
:config
(setq company-idle-delay 0.2)
(setq company-minimum-prefix-length 4)
(global-company-mode))(use-package expand-region
:bind
("M-e" . er/expand-region))(use-package multiple-cursors
:bind
(("C->" . mc/mark-next-like-this)
("C-<" . mc/mark-previous-like-this)
("C-c C-<" . mc/mark-all-like-this)
("M-<mouse-1>" . mc/add-cursor-on-click))
:config)(use-package smartparens-config
:diminish smartparens-mode
:ensure smartparens
:config (show-smartparens-global-mode t)
:hook ((prog-mode markdown-mode org-mode LaTeX-mode) . turn-on-smartparens-mode))(use-package which-key
:diminish which-key-mode
:config
(which-key-mode)
(which-key-setup-minibuffer)
;; (which-key-setup-side-window-right-bottom)
(setq which-key-idle-delay 1)
(setq which-key-special-keys nil))(use-package avy
:bind* (("C-," . avy-pop-mark)
("M-j" . avy-goto-char)
("M-k" . avy-goto-word-1)
("M-g n" . avy-resume)
("M-g w" . avy-goto-word-1)
("M-g f" . avy-goto-line)
("M-g l c" . avy-copy-line)
("M-g l m" . avy-move-line)
("M-g r c" . avy-copy-region)
("M-g r m" . avy-move-region)
("M-g p" . avy-goto-paren)
("M-g c" . avy-goto-conditional)
("M-g M-g" . avy-goto-line))
:config
(defun avy-goto-paren ()
(interactive)
(avy--generic-jump "\\s(" nil 'pre))
(defun avy-goto-conditional ()
(interactive)
(avy--generic-jump "\\s(\\(if\\|cond\\|when\\|unless\\)\\b" nil 'pre))
(setq avy-timeout-seconds 0.3)
(setq avy-all-windows 'all-frames)
;; (defun avy-action-copy-and-yank (pt)
;; "Copy and yank sexp starting on PT."
;; (avy-action-copy pt)
;; (yank))
;; (defun avy-action-kill-and-yank (pt)
;; "Kill and yank sexp starting on PT."
;; (avy-action-kill-stay pt)
;; (yank))
;; (setq avy-dispatch-alist
;; '((?w . avy-action-copy)
;; (?k . avy-action-kill-move)
;; (?K . avy-action-kill-stay)
;; (?m . avy-action-mark)
;; (?n . avy-action-copy)
;; (?y . avy-action-copy-and-yank)
;; (?Y . avy-action-kill-and-yank)))
;; (setq avy-keys
;; '(?c ?a ?s ?d ?e ?f ?h ?w ?y ?j ?k ?l ?n ?m ?v ?r ?u ?p))
)(use-package link-hint
:bind*
("M-g l o" . link-hint-open-link)
("M-g l w" . link-hint-copy-link))(use-package ace-popup-menu
:config
(ace-popup-menu-mode 1))(use-package ace-window
:bind* ("C-o" . ace-window)
:config
(setq aw-keys '(?a ?s ?d ?f ?g ?j ?k ?l))
(setq aw-scope 'global)
(defun aw-switch-buffer (window)
"Swift buffer in WINDOW."
(select-window window)
(ivy-switch-buffer))
(setq aw-dispatch-alist
'((?x aw-delete-window " Ace - Delete Window")
(?m aw-swap-window " Ace - Swap Window")
(?n aw-flip-window)
(?c aw-split-window-fair " Ace - Split Fair Window")
(?v aw-split-window-vert " Ace - Split Vert Window")
(?h aw-split-window-horz " Ace - Split Horz Window")
(?i delete-other-windows " Ace - Maximize Window")
(?b aw-switch-buffer " Ace - Switch Buffer")
(?o delete-other-windows))))(use-package visual-regexp
:bind
(("C-c r" . vr/replace)
("C-c q" . vr/query-replace)
;; if you use multiple-cursors, this is for you:
("C-c e" . vr/mc-mark))
:config
(use-package visual-regexp-steroids))(use-package tex
:ensure auctex
:diminish reftex-mode
:mode ("\\.tex\\'" . latex-mode)
:bind
(:map TeX-mode-map
("M-q" . ales/fill-paragraph))
:config
(setq TeX-auto-save t)
(setq TeX-parse-self t)
(setq TeX-save-query nil)
;; (add-hook 'LaTeX-mode-hook 'visual-line-mode) ;; makes swiper super slow
(add-hook 'LaTeX-mode-hook 'flyspell-mode)
(setq LaTeX-math-abbrev-prefix "~")
(add-hook 'LaTeX-mode-hook 'LaTeX-math-mode)
(add-hook 'LaTeX-mode-hook 'turn-on-reftex)
(define-auto-insert "\\.tex$" "latex-template.tex")
(setq reftex-plug-into-AUCTeX t)
(setq preview-scale-function 1)
(setq reftex-ref-macro-prompt nil)
(setq TeX-PDF-mode t)
(add-hook
'LaTeX-mode-hook
(lambda ()
(TeX-auto-add-type "theorem" "mg-LaTeX")
;; Self Parsing -- see (info "(auctex)Hacking the Parser").
(defvar mg-LaTeX-theorem-regexp
(concat "\\\\newtheorem{\\(" TeX-token-char "+\\)}")
"Matches new theorems.")
(defvar mg-LaTeX-auto-theorem nil
"Temporary for parsing theorems.")
(defun mg-LaTeX-theorem-prepare ()
"Clear `mg-LaTex-auto-theorem' before use."
(setq mg-LaTeX-auto-theorem nil))
(defun mg-LaTeX-theorem-cleanup ()
"Move theorems from `mg-LaTeX-auto-theorem' to `mg-LaTeX-theorem-list'.
Add theorem to the environment list with an optional argument."
(mapcar (lambda (theorem)
(add-to-list 'mg-LaTeX-theorem-list (list theorem))
(LaTeX-add-environments
`(,theorem ["Name"])))
mg-LaTeX-auto-theorem))
;; FIXME: This does not seem to work unless one does a manual reparse.
(add-hook 'TeX-auto-prepare-hook 'mg-LaTeX-theorem-prepare)
(add-hook 'TeX-auto-cleanup-hook 'mg-LaTeX-theorem-cleanup)
(TeX-auto-add-regexp `(,mg-LaTeX-theorem-regexp 1 mg-LaTeX-auto-theorem))))
(add-hook 'TeX-language-dk-hook
(lambda () (ispell-change-dictionary "dansk")))
;; Use Skim as viewer, enable source <-> PDF sync
;; make latexmk available via C-c C-c
;; Note: SyncTeX is setup via ~/.latexmkrc (see below)
(add-to-list 'TeX-command-list '("latexmk" "latexmk -pdf %s" TeX-run-TeX nil t
:help "Run latexmk on file"))
(add-to-list 'TeX-command-list '("make" "make" TeX-run-TeX nil t
:help "Runs make"))
(add-hook 'TeX-mode-hook '(lambda () (setq TeX-command-default "latexmk")))
(add-hook 'TeX-mode-hook '(lambda () (setq company-minimum-prefix-length 2)))
(defun ales/fill-paragraph (&optional P)
"When called with prefix argument call `fill-paragraph'.
Otherwise split the current paragraph into one sentence per line."
(interactive "P")
(if (not P)
(save-excursion
(let ((fill-column 12345678)) ;; relies on dynamic binding
(fill-paragraph) ;; this will not work correctly if the paragraph is
;; longer than 12345678 characters (in which case the
;; file must be at least 12MB long. This is unlikely.)
(let ((end (save-excursion
(forward-paragraph 1)
(backward-sentence)
(point-marker)))) ;; remember where to stop
(beginning-of-line)
(while (progn (forward-sentence)
(<= (point) (marker-position end)))
(just-one-space) ;; leaves only one space, point is after it
(delete-char -1) ;; delete the space
(newline) ;; and insert a newline
(LaTeX-indent-line) ;; TODO: fix-this
))))
;; otherwise do ordinary fill paragraph
(fill-paragraph P)))
;; use Skim as default pdf viewer
;; Skim's displayline is used for forward search (from .tex to .pdf)
;; option -b highlights the current line; option -g opens Skim in the background
(setq TeX-view-program-selection '((output-pdf "PDF Viewer")))
(setq TeX-view-program-list
'(("PDF Viewer" "/Applications/Skim.app/Contents/SharedSupport/displayline -b -g %n %o %b")))
(setq TeX-source-correlate-method 'synctex
TeX-source-correlate-mode t
TeX-source-correlate-start-server t));; (use-package cdlatex
;; :hooks LaTeX-mode
;; :config
;; (add-to-list 'cdlatex-math-modify-alist
;; '(?B "\\mathbb" nil t nil nil))
;; (setq cdlatex-env-alist
;; '(("tikz-cd" "\\begin{tikz-cd}\n?\n\end{tikz-cd}\n" "\\\\?")
;; ("tikz" "\\begin{tikz-cd}\n?\n\end{tikz}\n" "\\\\?")))
;; (add-hook 'LaTeX-mode-hook 'turn-on-cdlatex) ; with AUCTeX LaTeX mode
;; (setq cdlatex-command-alist
;; '(("ww" "Insert \\text{}" "\\text{?}" cdlatex-position-cursor nil nil t)
;; ("bb" "Insert \\mathbb{}" "\\mathbb{?}" cdlatex-position-cursor nil nil t)
;; ("lm" "Insert \\lim_{}" "\\lim_{?}" cdlatex-position-cursor nil nil t)
;; ("dm" "Insert display math equation" "\\[\n?\n\\]" cdlatex-position-cursor nil t nil)
;; ("equ*" "Insert equation* environment" "\\begin{equation*}\n?\n\\end{equation*}" cdlatex-position-cursor nil t nil)))
;; );; (use-package latex-preview-pane
;; :hook (LaTeX-mode . latex-preview-pane-mode))(use-package recentf
:config
(setq recentf-exclude '("COMMIT_MSG" "COMMIT_EDITMSG" "github.*txt$"
".*png$" ".*cache$"))
(setq recentf-max-saved-items 50))(use-package projectile
:bind-keymap
("C-c p" . projectile-command-map)
:config
(setq projectile-mode-line
'(:eval (if (projectile-project-p)
(format " [%s]"
(projectile-project-name))
"")))
(projectile-mode)
)(use-package ivy
:demand
:diminish ivy-mode
:ensure t
:init
(unbind-key "M-i")
:bind*
(( "C-r" . ivy-resume)
( "C-c v" . ivy-push-view)
( "C-c V" . ivy-pop-view)
:map ivy-minibuffer-map
("M-y" . ivy-next-line)
("<return>" . ivy-alt-done)
("C-M-h" . ivy-previous-line-and-call)
("C-:" . ivy-dired)
("C-c o" . ivy-occur)
("M-o" . ivy-dispatching-done)
("C-M-o" . ivy-dispatching-call)
)
:config
(ivy-mode 1)
(setq ivy-use-virtual-buffers t)
(setq ivy-height 12)
(setq ivy-count-format "%d/%d | ")
(setq ivy-extra-directories nil)
(setq ivy-display-style 'fancy)
(setq magit-completing-read-function 'ivy-completing-read)
(setq projectile-completion-system 'ivy)
;; (setq ivy-switch-buffer-faces-alist
;; '((emacs-lisp-mode . swiper-match-face-1)
;; (dired-mode . ivy-subdir)
;; (org-mode . org-level-5)))
(defun ora-insert (x)
(insert
(if (stringp x)
x
(car x))))
(defun ora-kill-new (x)
(kill-new
(if (stringp x)
x
(car x))))
(ivy-set-actions
t
'(("i" ora-insert "insert")
("w" ora-kill-new "copy"))))(use-package swiper
:demand
:config
)(use-package counsel
;;:ensure-system-package (rg . ripgrep)
:demand
:bind
(( "C-s" . counsel-grep-or-swiper)
;; ( "C-c c" . counsel-org-capture)
( "M-g g" . counsel-rg)
( "M-i" . counsel-imenu)
( "M-x" . counsel-M-x)
( "C-x C-f" . counsel-find-file)
( "<f1> f" . counsel-describe-function)
( "<f1> v" . counsel-describe-variable)
( "<f1> l" . counsel-load-library)
( "<f2> i" . counsel-info-lookup-symbol)
( "<f2> u" . counsel-unicode-char)
( "C-h b" . counsel-descbinds)
( "C-c g" . counsel-git)
( "C-c k" . counsel-ag)
( "C-x l" . locate-counsel)
( "C-c g" . counsel-git)
( "C-c j" . counsel-git-grep)
("M-y" . counsel-yank-pop)
:map ivy-minibuffer-map
("M-y" . ivy-next-line)
)
:config
(setq imenu-auto-rescan t)
(advice-add 'counsel-grep-or-swiper :before 'avy-push-mark)
(advice-add 'counsel-rg :before (lambda (&rest _) (xref-push-marker-stack)))
(setq counsel-locate-cmd 'counsel-locate-cmd-mdfind)
(setq counsel-find-file-ignore-regexp "\\.|\\.DS_Store")
(defun ivy-copy-to-buffer-action (x)
(with-ivy-window
(insert x)))
(ivy-set-actions 'counsel-imenu
'(("I" ivy-copy-to-buffer-action "insert"))))(use-package flyspell-correct-ivy
:bind ("C-M-;" . flyspell-correct-wrapper)
:init
(setq flyspell-correct-interface #'flyspell-correct-ivy))(use-package ivy-hydra)(use-package wgrep)(use-package presentation)(use-package symbol-overlay
:commands (symbol-overlay-mode)
:bind (("M-p" . symbol-overlay-jump-prev)
("M-p" . symbol-overlay-jump-next)
("M-<up>" . symbol-overlay-jump-prev)
("M-<down>" . symbol-overlay-jump-next)
("M-g o" . symbol-overlay-hydra/body))
:hook ((prog-mode . symbol-overlay-mode))
:config
(defhydra symbol-overlay-hydra (:color pink :hint nil :timeout 5)
"
_p_ ^^ _b_ back _h_ highlight _i_ isearch
_<_ _>_ _d_ definition _R_ remove _Q_ query-replace
_n_ ^^ _w_ save ^^ _r_ rename
"
("<" symbol-overlay-jump-first)
(">" symbol-overlay-jump-last)
("p" symbol-overlay-jump-prev)
("n" symbol-overlay-jump-next)
("d" symbol-overlay-jump-to-definition)
("b" symbol-overlay-echo-mark)
("h" symbol-overlay-put :color blue)
("R" symbol-overlay-remove-all :color blue)
("w" symbol-overlay-save-symbol :color blue)
("t" symbol-overlay-toggle-in-scope)
("i" symbol-overlay-isearch-literally :color blue)
("Q" symbol-overlay-query-replace :color blue)
("r" symbol-overlay-rename :color blue)
("q" nil)
)
)(use-package moe-theme
:config
(setq moe-theme-resize-markdown-title '(2.0 1.7 1.5 1.3 1.0 1.0))
(setq moe-theme-resize-org-title '(1.4 1.2 1.1 1.0 1.0 1.0 1.0 1.0 1.0))
(setq moe-theme-resize-rst-title '(2.0 1.7 1.5 1.3 1.1 1.0))
(moe-light))(use-package solarized-theme
:config
;; make the fringe stand out from the background
;; (setq solarized-distinct-fringe-background t)
;; Don't change the font for some headings and titles
(setq solarized-use-variable-pitch nil)
;; make the modeline high contrast
(setq solarized-high-contrast-mode-line t)
;; Use less bolding
;; (setq solarized-use-less-bold t)
;; Use more italics
;; (setq solarized-use-more-italic t)
;; Use less colors for indicators such as git:gutter, flycheck and similar
;; (setq solarized-emphasize-indicators nil)
;; Don't change size of org-mode headlines (but keep other size-changes)
;; (setq solarized-scale-org-headlines nil)
;; Avoid all font-size changes
;; (setq solarized-height-minus-1 1.0)
;; (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)
;; (load-theme 'solarized-light t)
)(defun get-file-dir-or-home ()
"If inside a file buffer, return the directory, else return home"
(interactive)
(let ((filename (buffer-file-name)))
(if (not (and filename (file-exists-p filename)))
"~/"
(file-name-directory filename))))
(defun iterm-goto-filedir-or-home ()
"Go to present working dir and focus iterm"
(interactive)
(do-applescript
(concat
" tell application \"iTerm2\"\n"
" tell the current session of current window\n"
(format " write text \"cd %s\" \n"
;; string escaping madness for applescript
(replace-regexp-in-string "\\\\" "\\\\\\\\"
(shell-quote-argument (or default-directory "~"))))
" end tell\n"
" end tell\n"
" do shell script \"open -a iTerm\"\n"
))
)
(defun iterm-focus ()
(interactive)
(do-applescript
" do shell script \"open -a iTerm\"\n"
))
(use-package sml-mode
:mode ("\\.sml\\'" "\\.pico\\'" "\\.picox\\'" "\\.femto\\'" "\\.atto\\'" "\\.trp\\'")
:interpreter "sml")(use-package tuareg
:config
(let ((opam-share (ignore-errors (car (process-lines "opam" "config" "var" "share")))))
(when (and opam-share (file-directory-p opam-share))
;; Register Merlin
(add-to-list 'load-path (expand-file-name "emacs/site-lisp" opam-share))
(autoload 'merlin-mode "merlin" nil t nil)
;; Automatically start it in OCaml buffers
(add-hook 'tuareg-mode-hook 'merlin-mode t)
(add-hook 'caml-mode-hook 'merlin-mode t)
;; Use opam switch to lookup ocamlmerlin binary
(setq merlin-command 'opam)))
;; (dolist
;; (var (car (read-from-string
;; (shell-command-to-string "opam config env --sexp"))))
;; (setenv (car var) (cadr var)))
;; Update the emacs path
;; (setq exec-path (split-string (getenv "PATH") path-separator))
;; Update the emacs load path
;; (push (concat (getenv "OCAML_TOPLEVEL_PATH")
;; "/../../share/emacs/site-lisp") load-path)
;; Automatically load utop.el
;; Add the opam lisp dir to the emacs load path
(add-to-list
'load-path
(replace-regexp-in-string
"\n" "/share/emacs/site-lisp"
(shell-command-to-string "opam config var prefix")))
;; Automatically load utop.el
(autoload 'utop "utop" "Toplevel for OCaml" t)
(autoload 'utop-minor-mode "utop" "Minor mode for utop" t)
(add-hook 'tuareg-mode-hook 'utop-minor-mode)
)
(require 'opam-user-setup "~/.emacs.d/opam-user-setup.el")
(use-package reason-mode
:config
;;----------------------------------------------------------------------------
;; Reason setup
;;----------------------------------------------------------------------------
(defun shell-cmd (cmd)
"Returns the stdout output of a shell command or nil if the command returned
an error"
(car (ignore-errors (apply 'process-lines (split-string cmd)))))
(defun reason-cmd-where (cmd)
(let ((where (shell-cmd cmd)))
(if (not (string-equal "unknown flag ----where" where))
where)))
(let* ((refmt-bin (or (reason-cmd-where "refmt ----where")
(shell-cmd "which refmt")
(shell-cmd "which bsrefmt")))
(merlin-bin (or (reason-cmd-where "ocamlmerlin ----where")
(shell-cmd "which ocamlmerlin")))
(merlin-base-dir (when merlin-bin
(replace-regexp-in-string "bin/ocamlmerlin$" "" merlin-bin))))
;; Add merlin.el to the emacs load path and tell emacs where to find ocamlmerlin
(when merlin-bin
(add-to-list 'load-path (concat merlin-base-dir "share/emacs/site-lisp/"))
(setq merlin-command merlin-bin))
(when refmt-bin
(setq refmt-command refmt-bin)))
(require 'reason-mode)
(require 'merlin)
(add-hook 'reason-mode-hook (lambda ()
(add-hook 'before-save-hook 'refmt-before-save)
(merlin-mode)))
(setq merlin-ac-setup t)
)(use-package alchemist)(setq scheme-program-name "petite")
(defun scheme-send-buffer-and-go ()
"Send entire content of the buffer to the Inferior Scheme process\
and goto the Inferior Scheme buffer."
(interactive)
(scheme-send-region-and-go (point-min) (point-max)))
;; Configuration run when scheme-mode is loaded
(add-hook 'scheme-mode-hook
(lambda ()
;; indent with spaces
(setq indent-tabs-mode nil)
(setq-local comment-start ";;; ")
;; Danvy-style key bindings
(local-set-key (kbd "C-c d") 'scheme-send-definition-and-go)
(local-set-key (kbd "C-c C-b") 'scheme-send-buffer-and-go)
;; fix indentation of some special forms
(put 'cond 'scheme-indent-hook 0)
(put 'guard 'scheme-indent-hook 1)
(put 'when 'scheme-indent-hook 1)
(put 'unless 'scheme-indent-hook 1)
;; special forms from Petite Chez Scheme
(put 'trace-lambda 'scheme-indent-hook 2)
(put 'extend-syntax 'scheme-indent-hook 1)
(put 'with 'scheme-indent-hook 0)
(put 'parameterize 'scheme-indent-hook 0)
(put 'define-syntax 'scheme-indent-hook 1)
(put 'syntax-case 'scheme-indent-hook 0)
;; special forms for Schelog
(put '%rel 'scheme-indent-hook 1)
(put '%which 'scheme-indent-hook 1)
))
;; (defun my-pretty-lambda ()
;; "make some word or string show as pretty Unicode symbols"
;; (setq prettify-symbols-alist
;; '(
;; ("lambda" . 955) ; λ
;; ))
;; (prettify-symbols-mode 1))
;; (add-hook 'scheme-mode-hook 'my-pretty-lambda)
(add-hook 'inferior-scheme-mode-hook
(lambda ()
;; Overwrite the standard 'switch-to-buffer' to use
;; 'switch-to-buffer-other-window'
(defun switch-to-scheme (eob-p)
"Switch to the scheme process buffer.
With argument, position cursor at end of buffer."
(interactive "P")
(if (or (and scheme-buffer (get-buffer scheme-buffer))
(scheme-interactively-start-process))
(switch-to-buffer-other-window scheme-buffer)
(error "No current process buffer. See variable `scheme-buffer'"))
(when eob-p
(push-mark)
(goto-char (point-max))))))
(setq auto-mode-alist
(append '(("\\.ss$" . scheme-mode)
("\\.scm$" . scheme-mode)
("\\.sim$" . scheme-mode))
auto-mode-alist))
(setenv "TEXINPUTS" (concat "~/.latex/scheme-listings/:" (getenv "TEXINPUTS")))(use-package proof-general
:defines proof-mode
:mode ("\\.v\\'" . coq-mode)
:bind (
:map coq-mode-map
("C-c C-." . 'proof-goto-point)
("C-.". proof-goto-point)
("C-c .". proof-goto-end-of-locked)
("M-n". proof-assert-next-command-interactive)
)
:init
(eval-after-load "proof-script"
'(progn
(define-key proof-mode-map (kbd "C-c C-.") 'proof-goto-point)
(define-key proof-mode-map (kbd "C-.") 'proof-goto-point)
(define-key proof-mode-map (kbd "C-c .") 'proof-goto-end-of-locked)
(define-key proof-mode-map (kbd "M-n") 'proof-assert-next-command-interactive)
(setq proof-three-window-mode-policy 'hybrid)
(setq proof-script-fly-past-comments t)))
;; (with-eval-after-load 'coq
;; (setq coq-compile-before-require nil)
;; ;; Small convenience for commonly written commands.
;; (define-key coq-mode-map "\C-c\C-m" "\nend\t")
;; (define-key coq-mode-map "\C-c\C-e"
;; 'endless/qed)
;; (defun endless/qed ()
;; (interactive)
;; ;; (unless (memq (char-before) '(?\s ?\n ?\r))
;; ;; (insert " "))
;; (insert "Qed.")
;; (proof-assert-next-command-interactive)))
;; (define-abbrev-table 'coq-mode-abbrev-table '())
;;(define-abbrev coq-mode-abbrev-table "re" "reflexivity.")
;;(define-abbrev coq-mode-abbrev-table "id" "induction")
;;(define-abbrev coq-mode-abbrev-table "si" "simpl.")
;;(advice-add 'proof-assert-next-command-interactive
;; :before #'expand-abbrev)
;;(defun open-after-coq-command ()
;; (when (looking-at-p " *(\\*")
;; (open-line 1)))
;;(advice-add 'proof-assert-next-command-interactive
;; :after #'open-after-coq-command)
)(use-package company-coq
:init
(setq company-coq-live-on-the-edge t)
:hook (coq-mode . company-coq-mode))(use-package ensime
:config
(setq ensime-startup-notification nil)
(defun tarao/ensime-sbt-ansi-color-workaround (&rest args)
"https://github.com/ensime/emacs-sbt-mode/issues/150"
(with-current-buffer (sbt:buffer-name)
(remove-hook 'comint-output-filter-functions 'ensime-inf-postoutput-filter)
(add-hook 'comint-output-filter-functions 'ensime-inf-postoutput-filter t)))
(advice-add 'ensime-sbt :after #'tarao/ensime-sbt-ansi-color-workaround))
(use-package scala-mode
:interpreter
("scala" . scala-mode))(use-package haskell-mode
:mode "\\.hs\\'"
:config
(let ((my-cabal-path (expand-file-name "~/.cabal/bin")))
(setenv "PATH" (concat my-cabal-path path-separator (getenv "PATH")))
(add-to-list 'exec-path my-cabal-path))
(setq haskell-tags-on-save t)
(setq haskell-process-type 'cabal-repl)
(add-hook 'haskell-mode-hook
(lambda ()
(set (make-local-variable 'company-backends)
(append '((company-capf company-dabbrev-code))
company-backends))))
(setq
haskell-process-suggest-remove-import-lines t
haskell-process-auto-import-loaded-modules t
haskell-process-log t)
(define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
(define-key haskell-mode-map (kbd "C-c C-z") 'haskell-interactive-switch)
(define-key haskell-mode-map (kbd "C-c C-n C-t") 'haskell-process-do-type)
(define-key haskell-mode-map (kbd "C-c C-n C-i") 'haskell-process-do-info)
(define-key haskell-mode-map (kbd "C-c C-n C-c") 'haskell-process-cabal-build)
(define-key haskell-mode-map (kbd "C-c C-n c") 'haskell-process-cabal)
(define-key haskell-cabal-mode-map (kbd "C-c C-z") 'haskell-interactive-switch)
(define-key haskell-cabal-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
(define-key haskell-cabal-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
(define-key haskell-cabal-mode-map (kbd "C-c c") 'haskell-process-cabal)
(define-key haskell-mode-map (kbd "C-c C-o") 'haskell-compile)
(define-key haskell-cabal-mode-map (kbd "C-c C-o") 'haskell-compile)
(use-package ghc
:init
(autoload 'ghc-init "ghc" nil t)
(setq haskell-hoogle-command "hoogle")
(use-package company-ghc
:init
(add-to-list 'company-backends 'company-ghc)
(custom-set-variables '(company-ghc-show-info t)))
(autoload 'ghc-debug "ghc" nil t)
(add-hook 'haskell-mode-hook (lambda () (ghc-init))))
)
(use-package intero
:config
(add-hook 'haskell-mode-hook 'intero-mode))(use-package markdown-mode
:ensure t
:commands (markdown-mode gfm-mode)
:mode (("README\\.md\\'" . gfm-mode)
("\\.md\\'" . markdown-mode)
("\\.txt\\'" . markdown-mode)
("\\.markdown\\'" . markdown-mode))
:init
(setq markdown-command "markdown")
:config
(add-hook 'markdown-mode-hook 'flyspell-mode))
(use-package js2-mode
:config
(add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
(add-to-list 'interpreter-mode-alist '("node" . js2-mode)))
(use-package tide
:ensure t
:after (typescript-mode company flycheck)
:hook ((typescript-mode . tide-setup)
(typescript-mode . tide-hl-identifier-mode)
(before-save . tide-formater-before-save)))
(use-package web-mode
:ensure t
:init
(add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.tsx\\'" . typescript-mode))
(add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-mode))
(setq web-mode-enable-current-element-highlight t))
(use-package fstar-mode
:mode (("\\.fst\\')" . fstar-mode)))(use-package racket-mode
:mode "\\.rkt\\'")(use-package elpy
:ensure t
:init
(if (eq 'system-type "darwin")
(defvar elpy-rpc-python-command "python3")
(defvar elpy-rpc-python-command "python"))
(elpy-enable))(let ((private-file (concat user-emacs-directory "private.el")))
(when (file-exists-p private-file)
(load-file (concat user-emacs-directory "private.el"))))