coldnew's emacs

;; -*- lexical-binding: t -*-

(setq load-prefer-newer t)

;; We set `user-emacs-directory' here so we can use command-line
;; switch different emacs configuration like following:
;;
;;    emacs -q -l ~/coldnew-spacemacs/init.el
(defconst user-emacs-directory
  (file-name-directory (or load-file-name (buffer-file-name)))
  "My emacs config directory.")

(defconst user-cache-directory
  (file-name-as-directory (concat user-emacs-directory ".cache"))
  "My emacs storage area for persistent files.")
;; create the `user-cache-directory' if not exists
(make-directory user-cache-directory t)

(defconst user-ramdisk-directory
    (let ((ramdisk "/Volumes/ramdisk/")
          (user-ramdisk                   ; ~/ramdisk/
           (concat (getenv "HOME") "/ramdisk/"))
          (tmp "/tmp/"))
      (if (eq system-type 'darwin)
          ramdisk
        ;; if ~/ramdisk/ exist, use it
        (if (file-exists-p user-ramdisk)
            user-ramdisk
          ;; fallcack to system default ramdisk dir
          temporary-file-directory)))
  "My ramdisk path in system.")

(defun my/load-secret ()
  "Load my secret setting include password... etc."
  (let ((secret "~/.secret.el.gpg"))
    (when (file-exists-p secret) (load-file secret))))

;; This must come before configurations of installed packages.
;; Don't delete this line. If you don't want it, just comment it out by adding a
;; semicolon to the start of the line. You may delete these explanatory
;; comments.
(package-initialize)

(add-to-list 'package-archives '("melpa" . "http://melpa.milkbox.net/packages/"))

(require 'use-package)                  ; Installed by Cask
;; Auto install non-installed packages.
;; (setq use-package-always-ensure t)

(require 'paradox)                  ; Installed by Cask

(setq user-full-name "Yen-Chin, Lee")
(setq user-mail-address "coldnew.tw@gmail.com")

;; Only start server mode if I'm not root
(unless (string-equal "root" (getenv "USER"))
  (require 'server)
  (unless (server-running-p) (server-start)))

(setq mac-option-modifier 'super)
(setq mac-command-modifier 'meta)
(setq mac-pass-command-to-system nil)

(require 'noflet)
(defadvice save-buffers-kill-emacs (around no-query-kill-emacs activate)
  "Prevent annoying \"Active processes exist\" query when you quit Emacs."
  (noflet ((process-list ())) ad-do-it))

(setq kill-buffer-query-functions
      (remq 'process-kill-buffer-query-function
            kill-buffer-query-functions))

(setq-default custom-file (concat user-cache-directory "custom.el"))
;; load custom-file only when file exist
(when (file-exists-p custom-file)
  (load-file custom-file))

(require 'async)   ; Installed by Cask
;; If I'm edit my init.org, async generate init.el when save.
(defun tangle-init ()
  "If the current buffer is 'init.org' the code-blocks are tangled."
  (let ((buffer-name "async-make-init.el"))
    (when (equal (buffer-file-name)
                 (expand-file-name (concat user-emacs-directory "init.org")))
      ;; If previous building buffer exist, discard it
      ;; (when (get-buffer (concat "*" buffer-name "*"))
      ;;   (kill-buffer (concat "*" buffer-name "*")))
      ;; build with `make init.el' command
      (async-start-process buffer-name "make"
                           '(lambda (result)
                              (message "Re-Generate init.el")) "init.el"))))
;; Add to hook
(add-hook 'after-save-hook 'tangle-init)

(setq auto-save-list-file-prefix
      (concat user-cache-directory "auto-save-list/.saves-"))

(setq auto-save-interval 100)
(setq auto-save-timeout  60)
(setq auto-save-visited-file-name nil)
(setq delete-auto-save-files t)

(let ((backup-dir (concat user-cache-directory "backup")))
  ;; Move backup file to `~/.emacs.d/.cache/backup'
  (setq backup-directory-alist `(("." . ,backup-dir)))
  ;; Makesure backup directory exist
  (when (not (file-exists-p backup-dir))
    (make-directory backup-dir t)))

(setq delete-by-moving-to-trash nil)
(setq version-control t)
(setq kept-old-versions 10)
(setq kept-new-versions 20)
(setq delete-old-versions t)
(setq backup-by-copying t)

(eval-after-load 'bookmark
  '(progn
     (setq bookmark-default-file
           (concat user-cache-directory "bookmarks"))))

(eval-after-load 'dilwave
  '(progn
     (setq idlwave-config-directory
           (concat user-cache-directory "idlwave"))))

;; change srecode cache file path
(eval-after-load 'srecode
  '(progn
     (setq srecode-map-save-file
           (concat user-cache-directory "srecode-map.el"))))

(eval-after-load 'request
  '(progn
     (setq request-storage-directory
           (concat user-cache-directory "request"))))

(eval-after-load 'nsm
  '(progn
     (setq nsm-settings-file
           (concat user-cache-directory "network-security.data"))))

(eval-after-load 'url
  '(progn
     (setq url-configuration-directory
           (file-name-as-directory
            (concat user-cache-directory "url")))))

(req-package ag
  :if (executable-find "ag"))

brew install the_silver_searcher

emerge sys-apps/the_silver_searcher

(req-package ascii
  :config
  (defun ascii-toggle ()
    "Toggle ascii-mode."
    (interactive)
    (if (not (ascii-off)) (ascii-on)))

  ;; alias ascii to ascii-toggle
  (defalias 'ascii 'ascii-toggle))

(req-package ascii-art-to-unicode)

(req-package avy)

(req-package buffer-move)

(req-package bpr)

(req-package calfw)

(req-package cbm)

(req-package crux)

(req-package darkroom)

(req-package discover-my-major)

(when (require 'doxymacs nil 'noerror)
  (add-hook 'prog-mode-hook '(lambda () (doxymacs-mode))))

brew install doxymacs

emerge app-shells/doxymacs

(req-package esup)

(req-package exec-path-from-shell
  :config
  (when (memq window-system '(mac ns x))
    (exec-path-from-shell-initialize)))

(req-package expand-region
  :bind (("M-v" . er/expand-region)))

(req-package fancy-narrow)

(req-package focus)

(req-package google-translate)

(req-package howdoi)

(req-package htmlize)

(req-package hungry-delete
  :config
  (global-hungry-delete-mode))

(req-package hydra
  :config
  <<hydra-config>>)

(req-package iedit
  :bind (("C-;" . iedit-mode)))

(req-package know-your-http-well)

(req-package kurecolor)

(req-package lentic)

(req-package link-hint)

(req-package manage-minor-mode)

(req-package mustache)

(req-package mwim
  :bind
  (("C-a" . mwim-beginning-of-code-or-line)
   ("C-e" . mwim-end-of-code-or-line)))

(req-package moedict)

(req-package noflet)

(req-package nand2tetris
  :require (company company-nand2tetris nand2tetris-assembler)
  :if (file-exists-p "~/Workspace/nand2tetris")
  :config
  (setq nand2tetris-core-base-dir "~/Workspace/nand2tetris"))

(req-package pangu-spacing
  :config
  ;; start pangu-spacing globally
  (global-pangu-spacing-mode 1)
  ;; Always insert `real' space in org-mode.
  (add-hook 'org-mode-hook
            '(lambda ()
               (set (make-local-variable 'pangu-spacing-real-insert-separtor) t))))

(req-package password-generator :defer t)

(req-package rainbow-mode)

(req-package reveal-in-osx-finder
  :when (eq system-type 'darwin))

(req-package smartparens
  :require smartparens-config
  :config
  (smartparens-mode 1))

(req-package spray)

(req-package sicp)

(req-package string-inflection)

(req-package sx :require sx-load)

(req-package tldr
  :init
  (setq tldr-directory-path (concat user-cache-directory "tldr/"))
  (setq tldr-saved-zip-path (concat user-cache-directory "tldr-source.zip")))

(req-package travis)

export TRAVIS_TOKEN=XXXXXXX

(req-package url-shortener)

(req-package verify-url)

(req-package which-key
  :config
  ;; enable globally
  (which-key-mode)
  ;; Hide/Modify some function prefix in which-key show menu
  (setq which-key-description-replacement-alist
        '(("Prefix Command" . "prefix")
          ("which-key-show-next-page" . "wk next pg")
          ("\\`calc-" . "") ; Hide "calc-" prefixes when listing M-x calc keys
          ("/body\\'" . "") ; Remove display the "/body" portion of hydra fn names
          ("modi/" . "m/") ; The car is intentionally not "\\`modi/" to cover
                                        ; cases like `hydra-toggle/modi/..'.
          ("\\`hydra-" . "+h/")
          ("\\`org-babel-" . "ob/")
          ("\\`my/" . ""))))

(req-package xkcd
  :init
  (setq xkcd-cache-dir (concat user-cache-directory "xkcd/"))
  (when (not (file-directory-p xkcd-cache-dir))
    (make-directory xkcd-cache-dir :parents)))

(req-package zzz-to-char
  :bind (("M-z" . zzz-to-char)))

;; only use `bar' type of cursor shape
(add-hook 'minibuffer-setup-hook '(lambda () (setq cursor-type 'bar)))

;; define some helper function to insert to minibuffer quickly
(defun my/minibuffer-insert (p)
  (kill-line 0) (insert p))

(defun my/minibuffer-switch-to-ramdisk ()
  "Insert ramdisk path according to system type"
  (interactive)
  (my/minibuffer-insert user-ramdisk-directory))

(defun my/minibuffer-switch-to-home ()
  "Insert $HOME path."
  (interactive)
  (my/minibuffer-insert (file-name-as-directory (getenv "HOME"))))

(defun my/minibuffer-switch-to-rootdir ()
  "Insert / path."
  (interactive)
  (my/minibuffer-insert "/"))

(defun my/minibuffer-switch-to-tramp ()
  "Insert /ssh:."
  (interactive)
  (my/minibuffer-insert "/ssh:"))

(req-package savehist
  :config
  (setq savehist-file (concat user-cache-directory "savehist.dat"))
  (savehist-mode 1))

(eval-after-load 'minibuffer
  '(progn
     (lexical-let ((default-threshold gc-cons-threshold))
       (defun my/minibuffer-gc-setup-hook ()
         (setq gc-cons-threshold most-positive-fixnum))
       (add-hook 'minibuffer-setup-hook #'my/minibuffer-gc-setup-hook)
       ;; When exit, set back to default threshold
       (defun my/minibuffer-gc-exit-hook ()
         (setq gc-cons-threshold default-threshold))
       (add-hook 'minibuffer-exit-hook #'my/minibuffer-gc-exit-hook))))

(bind-keys :map minibuffer-local-map
           ("C-w" . backward-kill-word)
           ("M-p" . previous-history-element)
           ("M-n" . next-history-element)
           ("C-g" . minibuffer-keyboard-quit)
           ("M-t" . my/minibuffer-switch-to-ramdisk)
           ("M-h" . my/minibuffer-switch-to-home)
           ("M-/" . my/minibuffer-switch-to-rootdir)
           ("M-s" . my/minibuffer-switch-to-tramp))

;; fontify source code
(setq org-src-fontify-natively t)
;; Use current window when switch to source block
(setq org-src-window-setup 'current-window)
;; Disable prompting to evaluate babel blocks
(setq org-confirm-babel-evaluate nil)
;; Disable add validation link when export to HTML
(setq org-html-validation-link nil)

(add-to-list 'org-structure-template-alist
             '("E" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC"))
(add-to-list 'org-structure-template-alist
             '("S" "#+BEGIN_SRC sh\n?\n#+END_SRC"))
(add-to-list 'org-structure-template-alist
             '("p" "#+BEGIN_SRC plantuml :file uml.png \n?\n#+END_SRC"))

(org-babel-do-load-languages
 'org-babel-load-languages
 '((emacs-lisp . t)
   (C . t)
   (ditaa . t)
   (dot . t)
   (js . t)
   (latex . t)
   (perl . t)
   (python . t)
   (ruby . t)
   (sh . t)
   (plantuml . t)
   (clojure . t)))
;; make dot work as graphviz-dot
(add-to-list 'org-src-lang-modes '("dot" . graphviz-dot))

(setq org-link-abbrev-alist
      '(("google" . "http://www.google.com/search?q=")
        ("google-map" . "http://maps.google.com/maps?q=%s")
        ))

;; make agenda show on current window
(setq org-agenda-window-setup 'current-window)
;; highlight current in agenda
(add-hook 'org-agenda-mode-hook 'hl-line-mode)
;; Setup files for agenda
(setq org-agenda-files (list "~/Org/task/Office.org" "~/Org/task/Personal.org"))
;;
(setq org-directory "~/Org")
(setq org-default-notes-file (f-join org-directory "task" "Office.org"))

;; Always use `C-g' to exit agenda
(add-hook 'org-agenda-mode-hook
          '(lambda ()
             (local-set-key (kbd "C-g") 'org-agenda-exit)))

(eval-after-load 'ispell
  '(progn
     (add-to-list 'ispell-skip-region-alist '(":\\(PROPERTIES\\|LOGBOOK\\):" . ":END:"))
     (add-to-list 'ispell-skip-region-alist '("#\\+BEGIN_SRC" . "#\\+END_SRC"))
     ))

(use-package org-crypt
  :config
  ;; Auto encrypt when save file
  (org-crypt-use-before-save-magic)
  ;; Encrypt with tagname: `secret'
  (setq org-crypt-tag-matcher "secret")
  ;; Prevent the `secret' tag inherit by child
  ;; (The child item still will be encrypt)
  (setq org-tags-exclude-from-inheritance (quote ("secret")))
  ;; Use my own password to encrypt
  (setq org-crypt-key nil))

(use-package org-redmine
  :ensure t
  :config
  ;; NOTE: in personal private setting
  (setq org-redmine-uri nil)
  (setq org-redmine-auth-api-key nil)
  (setq org-redmine-auth-password nil)
                                        ;
  ;; Advice org-remine function so it will load my private config
  (defadvice org-redmine-get-issue (before load-password activate)
    (my/load-secret))
  (defadvice org-redmine-anything-show-issue-all (before load-password activate)
    (my/load-secret)))

(bind-keys :map org-mode-map
           ("M-p"   . org-previous-visible-heading)
           ("M-n"   . org-next-visible-heading)
           ("C-c a" . org-agenda)
           ("C-c c" . org-capture)
           ("C-c l" . org-stored-links)
           ("C-c b" . org-metaleft)
           ("C-c f" . org-metaright)
           ("C-c p" . org-metaup)
           ("C-c n" . org-metadown)
           ("C-c i" . org-insert-link)
           ("C-c I" . org-toggle-inline-images))

(bind-keys :map org-src-mode-map
           ("C-c C-c" . org-edit-src-exit))

(defvar coldnew-editor-map (make-keymap))

(define-minor-mode coldnew-editor-mode
  "coldnew's editor minor mode."
  :init-value t
  :keymap coldnew-editor-map)

(define-globalized-minor-mode global-coldnew-editor-mode
  coldnew-editor-mode (lambda ()
                        (if (not (minibufferp (current-buffer)))
                            (coldnew-editor-mode 1))))

;; Gloabal enable
(global-coldnew-editor-mode t)

(req-package linum :init (global-linum-mode 1))

(req-package linum-off
  :config
    (setq linum-disabled-mode-list
          '(eshell-mode shell-mode term-mode erc-mode compilation-mode
                        woman-mode w3m-mode calendar-mode org-mode)))

(global-auto-revert-mode 1)
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)
(setq revert-without-query '(".*")) ;; disable revert query

(req-package rainbow-delimiters
  :config
  (add-hook 'prog-mode-hook #'rainbow-delimiters-mode))

(req-package 'editorconfig
  :if (executable-find "editorconfig")
  :mode ("\\.editorconfig\\'" . conf-unix-mode))

(req-package dtrt-indent
  :config
  ;; enable dtrt-indent-mode globally
  (dtrt-indent-mode 1))

(req-package epa-file
  :config
  (epa-file-enable)
  ;; Control whether or not to pop up the key selection dialog.
  (setq epa-file-select-keys 0)
  ;; Cache passphrase for symmetric encryption.
  (setq epa-file-cache-passphrase-for-symmetric-encryption t))

(req-package tramp
  :init
  (setq tramp-persistency-file-name (concat user-cache-directory "tramp"))
  :config
  (setq tramp-default-method "rsync"))

(req-package whitespace-cleanup-mode
  :config
  (add-hook 'prog-mode-hook 'whitespace-cleanup-mode))

(req-package recentf
  :init
  (setq recentf-save-file (expand-file-name "recentf" user-cache-directory))
  :config
  (recentf-mode 1))

(req-package highlight-numbers
  :config
  ;; json-mode has it's own highlight numbers method
  (add-hook 'prog-mode-hook '(lambda()
                               (if (not (derived-mode-p 'json-mode))
                                   (highlight-numbers-mode)))))

(req-package highlight-escape-sequences
  :config
  ;; Make face the same as builtin face
  (put 'font-lock-regexp-grouping-backslash 'face-alias 'font-lock-builtin-face)
  ;; Enable globally
  (hes-mode 1))

(defun font-lock-comment-annotations ()
  "Highlight a bunch of well known comment annotations.
This functions should be added to the hooks of major modes for programming."
  (font-lock-add-keywords
   nil
   '(("\\<\\(FIX\\(ME\\)?\\|BUG\\|HACK\\):" 1 font-lock-warning-face t)
     ("\\<\\(NOTE\\):" 1 'org-level-2 t)
     ("\\<\\(TODO\\):" 1 'org-todo t)
     ("\\<\\(DONE\\):" 1 'org-done t))
   ))

(add-hook 'prog-mode-hook 'font-lock-comment-annotations)

(req-package undo-tree
  :config
  ;; Persistent undo-tree history across emacs sessions
  (let ((dir
         (file-name-as-directory (concat user-cache-directory "undo-tree"))))
    (setq undo-tree-history-directory-alist `(("." . ,dir))))
  (setq undo-tree-auto-save-history t)
  ;; global enable undo-tree
  (global-undo-tree-mode))

(req-package keyfreq
  :config
  ;; setup cache file
  (setq keyfreq-file (concat user-cache-directory "keyfreq"))
  (setq keyfreq-file-lock (concat keyfreq-file ".lock"))
  ;; enable globally
  (keyfreq-mode 1)
  (keyfreq-autosave-mode 1))

(req-package ethan-wspace
  :config
  ;; Turn off `mode-require-final-newline' since ethan-wspace
  ;; supersedes `require-final-newline'.
  (setq mode-require-final-newline nil)

  ;; Enable ethan-wspace globally
  (global-ethan-wspace-mode 1)

  ;; Prevent etha-wspace touch my TAB on makefile mode
  (add-hook 'makefile-mode-hook
            '(lambda()
               (setq ethan-wspace-errors (remove 'tabs ethan-wspace-errors))))

  ;; Not use in diff-mode since it breaking my syntax-highlight
  (add-hook 'diff-mode-hook
            '(lambda()
               (ethan-wspace-mode -1)))

  ;; Ignore no trailing newline error
  (setq-default ethan-wspace-errors (remove 'no-nl-eof ethan-wspace-errors)))

(req-package indent-guide
  :config
  ;; Only show indent-guide in idle-time.
  (setq indent-guide-delay 0.1))

(show-paren-mode 1)
(setq show-paren-delay 0)               ; no delay

(setq tab-always-indent 'complete)

(req-package god-mode
  :bind
  ("M-o" . god-local-mode)
  :config
  (bind-keys :map god-local-mode-map
             ("z" . repeat)
             ("i" . god-local-mode)))

(req-package vi-tilde-fringe
  :if window-system
  :config
  (global-vi-tilde-fringe-mode))

;; default state set to insert-state
(setq evil-default-state 'insert)

(setcdr evil-insert-state-map nil)
(define-key evil-insert-state-map
  (read-kbd-macro evil-toggle-key) 'evil-emacs-state)

(define-key evil-insert-state-map [escape] 'evil-normal-state)

(dolist (m evil-emacs-state-modes)
  (add-to-list 'evil-insert-state-modes m))

(req-package evil-leader
  :config
  ;; enable evil-leader globally
  (global-evil-leader-mode)
  ;; extra keybindings defined in `Keybinding' section
  <<evil-leader-keybindings>>)

(req-package evil-surround
  :config
  (global-evil-surround-mode 1))

(req-package projectile
  :config
  (projectile-global-mode)
  ;; save projectile-known-projects-file in cache folder
  (setq projectile-known-projects-file
        (concat user-cache-directory "projectile-bookmarks.eld"))
  (setq projectile-cache-file
        (concat user-cache-directory "projectile.cache"))
  ;; Enable projectile globally
  (projectile-global-mode))

(req-package semantic
  :config
  (setq semanticdb-default-save-directory
        (concat user-cache-directory "semanticdb/"))

  (global-semanticdb-minor-mode 1)
  (global-semantic-idle-scheduler-mode 1)

  (semantic-mode 1))

(req-package gdb
  :config
  ;; Use many window in gdb
  (setq gdb-many-windows t)
  ;; Display source file containing the main routine at startup.
  ;; Also display the main routine in the disassembly buffer if present.
  (setq gdb-show-main t))

(req-package realgud)

(req-package xcscope
  :config
  ;; Use gtas's cscope command
  (setq cscope-program "gtags-cscope")
  ;; basic setup
  (cscope-setup))

(req-package flycheck
  :config
  ;; enable globally
  (global-flycheck-mode))

;; Use fuzzy match in helm
(setq helm-M-x-fuzzy-match t)
(setq helm-buffers-fuzzy-matching t)
(setq helm-recentf-fuzzy-match t)

;; make helm can select anything even not match
(setq helm-move-to-line-cycle-in-source nil)
(setq helm-ff-search-library-in-sexp t)
(setq helm-ff-file-name-history-use-recentf t)

(req-package helm-projectile
  :require (helm projectile)
  :config
  ;; make projectile use helm as completion system
  (setq projectile-completion-system 'helm)
  ;; start helm-projectile
  (helm-projectile-on))

(req-package helm-gtags
  :config
  (setq helm-gtags-ignore-case t)
  (setq helm-gtags-auto-update t)
  (setq helm-gtags-use-input-at-cursor t)
  (setq helm-gtags-pulse-at-cursor t)
  ;; add to following modes
  (add-hook 'c-mode-hook #'helm-gtags-mode)
  (add-hook 'c++-mode-hook #'helm-gtags-mode))

(req-package helm-bm)

(req-package helm-yasnippet
  :require (helm yasnippet)
  :config
  (setq helm-yas-space-match-any-greedy t))

(req-package helm-cscope
  :config
  (add-hook 'c-mode-common-hook 'helm-cscope-mode))

(req-package fontawesome)

(req-package helm-swoop)

(req-package helm-dash
  :require helm)

(bind-keys :map helm-map
           ("TAB"   . helm-execute-persistent-action)
           ("<tab>" . helm-execute-persistent-action)
           ("C-w"   . backward-kill-word)
           ("M-t" . my/minibuffer-switch-to-ramdisk)
           ("M-h" . my/minibuffer-switch-to-home)
           ("M-/" . my/minibuffer-switch-to-rootdir)
           ("M-s" . my/minibuffer-switch-to-tramp))

(setq company-idle-delay nil)

(req-package company-c-headers
  :require company
  :config
  (add-to-list 'company-backends 'company-c-headers))

(req-package company-flx
  :require company
  :config
  (company-flx-mode +1))

(req-package company-statistics
  :config
  ;; save cache file to `user-cache-directory'
  (setq company-statistics-file (concat user-cache-directory
                                        "company-statistics-cache.el"))
  ;; start company-statictics-mode after init
  (add-hook 'after-init-hook 'company-statistics-mode))

(bind-keys :map company-active-map
           ("C-g" . company-abort)
           ("C-n" . company-select-next)
           ("C-s" . company-filter-candidates)
           ("C-p" . company-select-previouse)
           ("TAB" . company-complete-selction)
           ("<tab>" . company-complete-selction))

(bind-keys :map company-search-map
           ("C-n" . company-select-next)
           ("C-p" . company-select-previous))

(setq yas/prompt-functions '(yas-dropdown-prompt
                             yas-completing-prompt
                             yas-ido-prompt))

(setq yas/snippet-dirs (concat user-emacs-directory "snippets"))

(add-hook 'term-mode-hook (lambda() (yas-minor-mode -1)))

(defadvice yas-expand (around major-mode-expand activate)
  "Try to complete a structure template before point like org-mode does.
This looks for strings like \"<e\" on an otherwise empty line and
expands them.
Before use this function, you must setup `major-mode-name'-expand-alist variable.

Take emacs-lisp-mode as example, if you wand to use <r to expand your snippet `require'
in yasnippet, you muse setup the emacs-lisp-mode-expand-alist variable.

 (setq emacs-lisp-expand-alist '((\"r\" . \"require\")))"
  (let* ((l (buffer-substring (point-at-bol) (point)))
         (expand-symbol (intern (concat (symbol-name major-mode) "-expand-alist")))
         (expand-alist (if (boundp expand-symbol) (symbol-value expand-symbol) nil))
         a)
    (when (and (looking-at "[ \t]*$")
               (string-match "^[ \t]*<\\([a-zA-Z]+\\)$" l)
               (setq a (assoc (match-string 1 l) expand-alist)))
      (backward-delete-char (1+ (length (car-safe a))))
      (if (symbolp (cdr-safe a))
          (funcall (cdr-safe a))
        (insert (cdr-safe a)))
      t)
    ad-do-it))

(setq emacs-lisp-mode-expand-alist '(("r" . "require")))

(setq c-mode-expand-alist '(("i" . "include")))

(req-package arduino-mode
  :mode ("\\.pde\\'" "\\.ino\\'"))

(req-package android-mode
  :config
  (setq android-mode-sdk-dir (getenv "ANDROID_HOME")))

(req-package flymake-shell
  :require (flymake shell)
  :config (add-hook 'sh-set-shell-hook 'flymake-shell-load))

(req-package bison-mode
  :mode ("\\.y\\'" "\\.l\\'" "\\.jison\\'"))

(req-package bitbake
  :mode ("\\.bb\\'" "\\.bbappend\\'"))

(req-package brainfuck-mode
  :mode "\\.bf\\'")

(req-package crontab-mode
  :mode "\\.?cron\\(tab\\)?\\'")

(req-package cmake-mode
  :mode ("CMakeLists\\.txt\\'" "\\.cmake\\'"))

(req-package dockerfile-mode
  :mode "Dockerfile\\'")

(req-package dts-mode
  :mode ("\\.dts\\'" "\\.dtsi\\'"))

(req-package elixir-mode)

(req-package alchemist)

(req-package gnuplot
  :commands gnuplot-mode
  :mode "\\.gp$")

(req-package graphviz-dot-mode
  :mode "\\.dot\\'"
  :config
  ;; alias `dot-mode' to graphviz-dot-mode
  (defalias 'dot-mode 'graphviz-dot-mode))

(req-package glsl-mode
  :mode (("\\.vs\\'" . glsl-mode)
         ("\\.fs\\'" . glsl-mode)
         ("\\.gs\\'" . glsl-mode))
  :config
  (setq glsl-other-file-alist '(("\\.fs$" (".vs")) ("\\.vs$" (".fs")))))

(req-package js2-mode
  :mode "\\.js\\'")

(req-package js2-refactor)

(req-package jsx-mode
  :mode "\\.jsx\\'")

(req-package json-mode
  :mode "\\.json\\'")

(req-package json-reformat :commands json-reformat-region)

(req-package flymake-json
  :require flymake
  :config
  (add-hook 'json-mode-hook (lambda () (flymake-json-load))))

(req-package lua-mode
  :mode "\\.lua$")

(req-package markdown-mode
  :mode "\\.\\(md\\|markdown\\)\\'")

(req-package po-mode
  :mode "\\.po\\'\\|\\.po\\."
  :config

  ;; To use the right coding system automatically under Emacs 20 or newer,
  ;; also add:
  (when (require 'po nil 'noerror)
    (modify-coding-system-alist 'file "\\.po\\'\\|\\.po\\."
                                'po-find-file-coding-system))
  )

(req-package php-mode
  :mode "\\.php\\'")

(req-package python
  :mode (("\\.py\\'" . python-mode)
         ("SConstruct\\'" . python-mode)
         ("SConscript\\'" . python-mode)))

(req-package qml-mode
  :mode "\\.qml$")

(req-package ruby-mode
  :mode (("Gemfile\\'"  . ruby-mode)
         ("Kirkfile\\'" . ruby-mode)
         ("Rakefile\\'" . ruby-mode)
         ("Vagrantfile\\'" . ruby-mode)
         ("\\.builder\\'"  . ruby-mode)
         ("\\.gemspec\\'"  . ruby-mode)
         ("\\.irbrc\\'" . ruby-mode)
         ("\\.pryrc\\'" . ruby-mode)
         ("\\.rake\\'"  . ruby-mode)
         ("\\.rjs\\'"   . ruby-mode)
         ("\\.ru\\'"    . ruby-mode)
         ("\\.rxml\\'"  . ruby-mode))
  :config
  ;; We never want to edit Rubinius bytecode
  (add-to-list 'completion-ignored-extensions ".rbc"))

(req-package rust-mode
  :mode "\\.rs\\'")

(req-package llvm-mode)

(req-package lua-mode
  :mode "\\.lua$")

(req-package haskell-mode
  :mode "\\.hs\\'"
  :config
  <<haskell-config>>)

(req-package scala-mode2
  :mode "\\.scala$")

(req-package sbt-mode
  :mode "\\.sbt$")

(req-package ssh-config-mode
  :mode ((".ssh/config\\'"       . ssh-config-mode)
         ("sshd?_config\\'"      . ssh-config-mode)
         ("known_hosts\\'"       . ssh-known-hosts-mode)
         ("authorized_keys2?\\'" . ssh-authorized-keys-mode)))

(req-package swift-mode)

(req-package systemd)

(req-package toml-mode
  :mode "\\.toml$")

(use-package nxml-mode
  :mode (("\\.plist\\'" . nxml-mode)
         ("\\.rss\\'"   . nxml-mode)
         ("\\.svg\\'"   . nxml-mode)
         ("\\.xml\\'"   . nxml-mode)
         ("\\.xsd\\'"   . nxml-mode)
         ("\\.xslt\\'"  . nxml-mode)
         ("\\.pom$"     . nxml-mode))
  :config
  ;; Any file start with xml will be treat as nxml-mode
  (add-to-list 'magic-mode-alist '("<\\?xml" . nxml-mode))
  ;; Use nxml-mode instead of sgml, xml or html mode.
  (mapc
   (lambda (pair)
     (if (or (eq (cdr pair) 'xml-mode)
             (eq (cdr pair) 'sgml-mode))
         (setcdr pair 'nxml-mode)))
   auto-mode-alist))

(req-package yaml-mode)

(add-to-list 'magic-mode-alist
             `(,(lambda ()
                  (and (string= (file-name-extension (or (buffer-file-name) "")) "h")
                       (or (re-search-forward "#include <\\w+>"
                                              magic-mode-regexp-match-limit t)
                           (re-search-forward "\\W\\(class\\|template\\namespace\\)\\W"
                                              magic-mode-regexp-match-limit t)
                           (re-search-forward "std::"
                                              magic-mode-regexp-match-limit t))))
               . c++-mode))

(req-package dummy-h-mode
  :require cc-mode
  :mode "\\.h$"
  :config
  (add-hook 'dummy-h-mode-hook
            (lambda ()
              ;; use c-mode by default
              (setq dummy-h-mode-default-major-mode 'c-mode)
              ;; setup search limit
              (setq dummy-h-mode-search-limit 60000))))

(req-package c-eldoc
  :require eldoc
  :config
  (add-hook 'c-mode-common-hook
            '(lambda ()
               (setq c-eldoc-includes "`pkg-config --cflags --libs` -I./ -I../")
               (c-turn-on-eldoc-mode))))

(req-package cwarn
  :config
  (add-hook 'c-mode-common-hook '(lambda () (cwarn-mode 1))))

(defun my/cc-mode/highlight-if-0 ()
  "highlight c/c++ #if 0 #endif macros"
  (setq cpp-known-face 'default)
  (setq cpp-unknown-face 'default)
  (setq cpp-known-writable 't)
  (setq cpp-unknown-writable 't)
  (setq cpp-edit-list '(("0" '(foreground-color . "gray")  default both)
                        ("1" default font-lock-comment-face both)))
  (cpp-highlight-buffer t))

;; Add to c/c++ mode
(defun my/cc-mode/highlight-if-0-hook ()
  (when (or (eq major-mode 'c++-mode) (eq major-mode 'c-mode))
    (my/cc-mode/highlight-if-0)))
(add-hook 'after-save-hook #'my/cc-mode/highlight-if-0-hook)

(dolist (m '(c-mode c++-mode))
  (font-lock-add-keywords
   m
   '(("\\<\\(int8_t\\|int16_t\\|int32_t\\|int64_t\\|uint8_t\\|uint16_t\\|uint32_t\\|uint64_t\\)\\>" . font-lock-keyword-face))))

(req-package cpputils-cmake
  :require (flymake flycheck)
  :config
  (add-hook 'c-mode-common-hook
            (lambda ()
              (when (derived-mode-p 'c-mode 'c++-mode)
                (cppcm-reload-all)))))