Xiaojie's Emacs Init File Written in Org-Mode

(defun user-emacs-subdirectory (d) (expand-file-name d user-emacs-directory))
(defun user-emacs-file (f) (expand-file-name f user-emacs-directory))

(defconst user-emacs-savefile-dir
  (expand-file-name "savefile" user-emacs-directory)
  "This folder stores all the history and cache files")
(defconst user-emacs-backup-dir
  (expand-file-name "backup" user-emacs-directory)
  "This folder stores all the backup~ files")
(defconst user-emacs-autosave-dir
  (expand-file-name "autosave" user-emacs-directory)
  "This folder stores all the #autosave# files")

(unless (file-exists-p user-emacs-savefile-dir)
  (make-directory user-emacs-savefile-dir))
(unless (file-exists-p user-emacs-backup-dir)
  (make-directory user-emacs-backup-dir))
(unless (file-exists-p user-emacs-autosave-dir)
  (make-directory user-emacs-autosave-dir))

(setq custom-file (expand-file-name "custom.el" user-emacs-directory))
(when (file-exists-p custom-file)
  (load custom-file))

(add-to-list 'load-path (expand-file-name "elisp" user-emacs-directory))

(require 'package)
(setq package-archives
      '(("gnu" . "https://elpa.gnu.org/packages/")
        ("org" . "http://orgmode.org/elpa/")
        ("melpa" . "https://melpa.org/packages/")))

(package-initialize)
(setq package-enable-at-startup nil)

(require 'package)
(setq package-archives
      '(("gnu"   . "http://elpa.emacs-china.org/gnu/")
        ("melpa" . "http://elpa.emacs-china.org/melpa/")
        ("org"   . "http://elpa.emacs-china.org/org/")))

(package-initialize)
(setq package-enable-at-startup nil)

(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(setq use-package-verbose t
      use-package-always-ensure t)

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

;; Please don't load outdated byte code
(setq load-prefer-newer t)

(setq inhibit-startup-screen t)         ; disable startup screen

(setq ring-bell-function (lambda ()))   ; disable the annoying bell ring

(setq frame-title-format
      (list "[" '(:eval (projectile-project-name)) "]"
            " ψωETωψ ◎ %b"))

(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)
(setq uniquify-separator "/")
(setq uniquify-after-kill-buffer-p t)    ; rename after killing uniquified
(setq uniquify-ignore-buffers-re "^\\*") ; don't muck with special buffers

(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

(line-number-mode 1)
(column-number-mode 1)

(size-indication-mode t)

(display-time-mode 1)

(setq-default indicate-empty-lines t)
(when (not indicate-empty-lines)
  (toggle-indicate-empty-lines))

(global-display-line-numbers-mode)

(blink-cursor-mode -1)                  ; No blinking cursor

(setq make-pointer-invisible t)         ; Hide the mouse while typing

(global-font-lock-mode 1)               ; Syntax highlight
(global-hl-line-mode 1)                 ; Highlight cursor line

(show-paren-mode 1)                      ; Highlight parenthesis pairs
(setq show-paren-delay 0)                ; No delay
(setq blink-matching-paren-distance nil) ; Blinking parenthesis
(setq show-paren-style 'expression)      ; Highlight text between parenthesis

(use-package volatile-highlights
  :diminish ""
  :init (volatile-highlights-mode))

(use-package hl-todo
  :diminish ""
  :init (global-hl-todo-mode))

(setq scroll-margin 0
      scroll-conservatively 100000
      scroll-preserve-screen-position 1)

(setq auto-save-default nil)            ; No #autosave# files
(setq make-backup-files nil)            ; No backup~ files

(setq create-lockfiles nil)             ; No #.something symbolic link files

(defalias 'yes-or-no-p 'y-or-n-p)       ; y/n instead of yes/no

(setq confirm-kill-emacs 'yes-or-no-p)

(defun my/reload-emacs-init-el-file ()
  (interactive)
  (load-file (expand-file-name "init.el" user-emacs-directory)))

(defun my/reload-emacs-init-org-file ()
  (interactive)
  (org-babel-load-file (expand-file-name "init.org" user-emacs-directory)))

(defun prelude-swap-meta-and-super ()
  "Swap the mapping of Meta and Super.
Very useful for people using their Mac with a
Windows external keyboard from time to time."
  (interactive)
  (if (eq mac-command-modifier 'super)
      (progn
        (setq mac-command-modifier 'meta)
        (setq mac-option-modifier 'super)
        (message "Command is now bound to META and Option is bound to SUPER."))
    (setq mac-command-modifier 'super)
    (setq mac-option-modifier 'meta)
    (message "Command is now bound to SUPER and Option is bound to META.")))

(defun copy-file-name-to-clipboard ()
  "Copy the current buffer file name to the clipboard."
  (interactive)
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (buffer-file-name))))
    (when filename
      (kill-new filename)
      (message "Copied buffer file name '%s' to the clipboard." filename))))

(defun xah-open-in-external-app (&optional @fname)
  "Open the current file or dired marked files in external app.
The app is chosen from your OS's preference.

When called in emacs lisp, if @fname is given, open that.

URL `http://ergoemacs.org/emacs/emacs_dired_open_file_in_ext_apps.html'
Version 2019-01-18"
  (interactive)
  (let* (
         ($file-list
          (if @fname
              (progn (list @fname))
            (if (string-equal major-mode "dired-mode")
                (dired-get-marked-files)
              (list (buffer-file-name)))))
         ($do-it-p (if (<= (length $file-list) 5)
                       t
                     (y-or-n-p "Open more than 5 files? "))))
    (when $do-it-p
      (cond
       ((string-equal system-type "windows-nt")
        (mapc
         (lambda ($fpath)
           (w32-shell-execute "open" (replace-regexp-in-string "/" "\\" $fpath t t))) $file-list))
       ((string-equal system-type "darwin")
        (mapc
         (lambda ($fpath)
           (shell-command
            (concat "open " (shell-quote-argument $fpath))))  $file-list))
       ((string-equal system-type "gnu/linux")
        (mapc
         (lambda ($fpath) (let ((process-connection-type nil))
                            (start-process "" nil "xdg-open" $fpath))) $file-list))))))

(use-package projectile
  :ensure t
  :diminish projectile-mode
  :init (projectile-global-mode)
  ;; caching can speedup file and directory listings
  ;;(setq projectile-enable-caching t)
  ;; projectile cache file location
  (setq projectile-cache-file (expand-file-name  "projectile.cache" user-emacs-savefile-dir))
  :commands projectile-ag
  :config
  (define-key projectile-mode-map (kbd "s-p") 'projectile-command-map)
  (define-key projectile-mode-map (kbd "C-x p") 'projectile-command-map)

  (setq projectile-completion-system 'helm ; `ido' or `helm' interface?
        projectile-switch-project-action 'projectile-commander
        projectile-create-missing-test-files t)
  (add-to-list 'projectile-globally-ignored-files ".DS_Store")

  (def-projectile-commander-method ?d
    "Open project root in dired."
    (projectile-dired))

  (def-projectile-commander-method ?s
    "Open a *shell* buffer for the project."
    (projectile-run-shell))

  (def-projectile-commander-method ?c
    "Run `compile' in the project."
    (projectile-compile-project nil))

  (def-projectile-commander-method ?F
    "Git fetch."
    (magit-status)
    (call-interactively #'magit-fetch-current)))

brew install coreutils

(setq ls-lisp-use-insert-directory-program nil)

(setq ls-lisp-use-insert-directory-program t)

(use-package direx
  :ensure t
  :bind (("C-x j" . direx:jump-to-directory)
         ("C-x C-j" . direx:jump-to-directory)))

(setq dired-recursive-copies 'always)   ; recursive copies without asking
(setq dired-recursive-deletes 'top)     ; recursive deletes with asked only once

(setq dired-dwim-target t)

(add-hook 'dired-mode-hook (lambda () (dired-hide-details-mode 1)))
(setq dired-listing-switches "-alh")    ; human readable format

(global-auto-revert-mode 1)
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)

(use-package find-dired
   :ensure t
   :init (setq find-ls-option '("-print0 | xargs -0 ls -od" . "-od")))

(use-package peep-dired
  :defer t ; don't access `dired-mode-map' until `peep-dired' is loaded
  :bind (:map dired-mode-map
              ("P" . peep-dired)))

(use-package neotree
  :ensure t
  :defer t
  :bind ("C-x t n" . neotree-toggle)
  :config
  (setq projectile-switch-project-action 'neotree-projectile-action)
  (setq neo-show-hidden-files t)
  (setq neo-smart-open t))

(global-set-key [f2] 'neotree-toggle)
(global-set-key [f8] 'neotree-toggle)

(winner-mode 1)

(use-package windmove
  :bind
  (("s-<right>" . windmove-right)
   ("s-<left>" . windmove-left)
   ("s-<up>" . windmove-up)
   ("s-<down>" . windmove-down)))

(use-package buffer-move
  :config
  (global-set-key (kbd "<C-s-up>")     'buf-move-up)
  (global-set-key (kbd "<C-s-down>")   'buf-move-down)
  (global-set-key (kbd "<C-s-left>")   'buf-move-left)
  (global-set-key (kbd "<C-s-right>")  'buf-move-right))

(use-package switch-window
  :bind (("C-x o" . switch-window)))

(defun kill-this-buffer-volatile ()
    "Kill current buffer unconditionally, even if it has been modified."
    (interactive)
    (set-buffer-modified-p nil)
    (kill-this-buffer))

;; Kill the current visible buffer without confirmation unless the buffer has
;; been modified. In this last case, you have to answer y/n.
(global-set-key (kbd "C-x k") 'kill-this-buffer)
;; Unconditionally kill unmodified buffers.
(global-set-key (kbd "C-x K") 'kill-this-buffer-volatile)

(use-package avy
  :ensure t
  :init (setq avy-background t)
  :config
  (global-set-key (kbd "s-;") 'avy-goto-line)
  (global-set-key (kbd "s-l") 'avy-goto-line)
  (global-set-key (kbd "s-.") 'avy-goto-char-timer)
  (global-set-key (kbd "s-j") 'avy-goto-char-timer)
  (global-set-key (kbd "s-,") 'avy-pop-mark)
  (global-set-key (kbd "s-J") 'avy-pop-mark))

(defun my/smarter-move-beginning-of-line (arg)
  "Move point back to indentation of beginning of line.

Move point to the first non-whitespace character on this line.
If point is already there, move to the beginning of the line.
Effectively toggle between the first non-whitespace character and
the beginning of the line.

If ARG is not nil or 1, move forward ARG - 1 lines first.  If
point reaches the beginning or end of the buffer, stop there."
  (interactive "^p")
  (setq arg (or arg 1))

  ;; Move lines first
  (when (/= arg 1)
    (let ((line-move-visual nil))
      (forward-line (1- arg))))

  (let ((orig-point (point)))
    (back-to-indentation)
    (when (= orig-point (point))
      (move-beginning-of-line 1))))

;; remap C-a to `smarter-move-beginning-of-line'
(global-set-key [remap move-beginning-of-line]
                'my/smarter-move-beginning-of-line)

(defun xah-cut-line-or-region ()
  "Cut current line, or text selection.
When `universal-argument' is called first, cut whole buffer (respects `narrow-to-region').

URL `http://ergoemacs.org/emacs/emacs_copy_cut_current_line.html'
Version 2015-06-10"
  (interactive)
  (if current-prefix-arg
      (progn ; not using kill-region because we don't want to include previous kill
        (kill-new (buffer-string))
        (delete-region (point-min) (point-max)))
    (progn (if (use-region-p)
               (kill-region (region-beginning) (region-end) t)
             (kill-region (line-beginning-position) (line-beginning-position 2))))))

(global-set-key (kbd "C-w") 'xah-cut-line-or-region)

(defun xah-copy-line-or-region ()
  "Copy current line, or text selection.
When called repeatedly, append copy subsequent lines.
When `universal-argument' is called first, copy whole buffer (respects `narrow-to-region').

URL `http://ergoemacs.org/emacs/emacs_copy_cut_current_line.html'
Version 2018-09-10"
  (interactive)
  (if current-prefix-arg
      (progn
        (copy-region-as-kill (point-min) (point-max)))
    (if (use-region-p)
        (progn
          (copy-region-as-kill (region-beginning) (region-end)))
      (if (eq last-command this-command)
          (if (eobp)
              (progn )
            (progn
              (kill-append "\n" nil)
              (kill-append
               (buffer-substring-no-properties (line-beginning-position) (line-end-position))
               nil)
              (progn
                (end-of-line)
                (forward-char))))
        (if (eobp)
            (if (eq (char-before) 10 )
                (progn )
              (progn
                (copy-region-as-kill (line-beginning-position) (line-end-position))
                (end-of-line)))
          (progn
            (copy-region-as-kill (line-beginning-position) (line-end-position))
            (end-of-line)
            (forward-char)))))))

(global-set-key (kbd "M-w") 'xah-copy-line-or-region)
(global-set-key (kbd "M-[") 'xah-copy-line-or-region)

(defun xah-delete-blank-lines ()
  "Delete all newline around cursor.

URL `http://ergoemacs.org/emacs/emacs_shrink_whitespace.html'
Version 2018-04-02"
  (interactive)
  (let ($p3 $p4)
          (skip-chars-backward "\n")
          (setq $p3 (point))
          (skip-chars-forward "\n")
          (setq $p4 (point))
          (delete-region $p3 $p4)))

(defun xah-shrink-whitespaces ()
  "Remove whitespaces around cursor to just one, or none.

Shrink any neighboring space tab newline characters to 1 or none.
If cursor neighbor has space/tab, toggle between 1 or 0 space.
If cursor neighbor are newline, shrink them to just 1.
If already has just 1 whitespace, delete it.

URL `http://ergoemacs.org/emacs/emacs_shrink_whitespace.html'
Version 2018-04-02T14:38:04-07:00"
  (interactive)
  (let* (
         ($eol-count 0)
         ($p0 (point))
         $p1 ; whitespace begin
         $p2 ; whitespace end
         ($charBefore (char-before))
         ($charAfter (char-after ))
         ($space-neighbor-p (or (eq $charBefore 32) (eq $charBefore 9) (eq $charAfter 32) (eq $charAfter 9)))
         $just-1-space-p
         )
    (skip-chars-backward " \n\t")
    (setq $p1 (point))
    (goto-char $p0)
    (skip-chars-forward " \n\t")
    (setq $p2 (point))
    (goto-char $p1)
    (while (search-forward "\n" $p2 t )
      (setq $eol-count (1+ $eol-count)))
    (setq $just-1-space-p (eq (- $p2 $p1) 1))
    (goto-char $p0)
    (cond
     ((eq $eol-count 0)
      (if $just-1-space-p
          (delete-horizontal-space)
        (progn (delete-horizontal-space)
               (insert " "))))
     ((eq $eol-count 1)
      (if $space-neighbor-p
          (delete-horizontal-space)
        (progn (xah-delete-blank-lines) (insert " "))))
     ((eq $eol-count 2)
      (if $space-neighbor-p
          (delete-horizontal-space)
        (progn
          (xah-delete-blank-lines)
          (insert "\n"))))
     ((> $eol-count 2)
      (if $space-neighbor-p
          (delete-horizontal-space)
        (progn
          (goto-char $p2)
          (search-backward "\n" )
          (delete-region $p1 (point))
          (insert "\n"))))
     (t (progn
          (message "nothing done. logic error 40873. shouldn't reach here" ))))))

(global-set-key (kbd "M-\\") 'xah-shrink-whitespaces)

(defmacro bol-with-prefix (function)
  "Define a new function which calls FUNCTION.
Except it moves to beginning of line before calling FUNCTION when
called with a prefix argument. The FUNCTION still receives the
prefix argument."
  (let ((name (intern (format "endless/%s-BOL" function))))
    `(progn
       (defun ,name (p)
         ,(format
           "Call `%s', but move to the beginning of the line when called with a prefix argument."
           function)
         (interactive "P")
         (when p
           (forward-line 0))
         (call-interactively ',function))
       ',name)))

(global-set-key [remap paredit-kill] (bol-with-prefix paredit-kill))
(global-set-key [remap sp-kill-hybrid-sexp] (bol-with-prefix sp-kill-hybrid-sexp))
(global-set-key [remap org-kill-line] (bol-with-prefix org-kill-line))
(global-set-key [remap kill-line] (bol-with-prefix kill-line))

(global-set-key (kbd "C-k") (bol-with-prefix kill-line))

(use-package expand-region  
  :ensure t
  :defer t
  :config
  (defun ha/expand-region (lines)
    "Prefix-oriented wrapper around Magnar's `er/expand-region'.

Call with LINES equal to 1 (given no prefix), it expands the
region as normal.  When LINES given a positive number, selects
the current line and number of lines specified.  When LINES is a
negative number, selects the current line and the previous lines
specified.  Select the current line if the LINES prefix is zero."
    (interactive "p")
    (cond ((= lines 1)   (er/expand-region 1))
          ((< lines 0)   (ha/expand-previous-line-as-region lines))
          (t             (ha/expand-next-line-as-region (1+ lines)))))

  (defun ha/expand-next-line-as-region (lines)
    (message "lines = %d" lines)
    (beginning-of-line)
    (set-mark (point))
    (end-of-line lines))

  (defun ha/expand-previous-line-as-region (lines)
    (end-of-line)
    (set-mark (point))
    (beginning-of-line (1+ lines)))

  :bind (("C-=" . ha/expand-region)     ; wrapped version of `er/expand-region'
         ("C--" . er/contract-region)))

(defun narrow-or-widen-dwim (p)
  "If the buffer is narrowed, it widens. Otherwise, it narrows intelligently.
   Intelligently means: region, subtree, or defun, whichever
   applies first.

   With prefix P, don't widen, just narrow even if buffer is
   already narrowed."
  (interactive "P")
  (declare (interactive-only))
  (cond ((and (buffer-narrowed-p) (not p)) (widen))
        ((region-active-p)
         (narrow-to-region (region-beginning) (region-end)))
        ((derived-mode-p 'org-mode) (org-narrow-to-subtree))
        (t (narrow-to-defun))))

(global-set-key (kbd "C-x n x") 'narrow-or-widen-dwim)

(use-package fancy-narrow
  :ensure t
  :config
  (defun ha/highlight-block ()
    "Highlights a 'block' in a buffer defined by the first blank
     line before and after the current cursor position. Uses the
     'fancy-narrow' mode to high-light the block."
    (interactive)
    (let (cur beg end)
      (setq cur (point))
      (setq end (or (re-search-forward  "^\s*$" nil t) (point-max)))
      (goto-char cur)
      (setq beg (or (re-search-backward "^\s*$" nil t) (point-min)))
      (fancy-narrow-to-region beg end)
      (goto-char cur)))

  (defun ha/highlight-section (num)
    "If some of the buffer is highlighted with the `fancy-narrow'
     mode, then un-highlight it by calling `fancy-widen'.

     If region is active, call `fancy-narrow-to-region'.

     If NUM is 0, highlight the current block (delimited by blank
     lines). If NUM is positive or negative, highlight that number
     of lines.  Otherwise, called `fancy-narrow-to-defun', to
     highlight current function."
    (interactive "p")
    (cond
     ((fancy-narrow-active-p)  (fancy-widen))
     ((region-active-p)        (fancy-narrow-to-region (region-beginning) (region-end)))
     ((= num 0)                (ha/highlight-block))
     ((= num 1)                (fancy-narrow-to-defun))
     (t                        (progn (ha/expand-region num)
                                      (fancy-narrow-to-region (region-beginning) (region-end))
                                      (setq mark-active nil)))))

  :bind (("C-x n ." . ha/highlight-section)))
  ;; :bind (("C-M-+" . ha/highlight-section)
  ;;        ("C-<f12>" . ha/highlight-section)))

;; (use-package fancy-narrow
;;   :ensure t
;;   :config
;;   (defun ha/highlight-block ()
;;     "Highlights a 'block' in a buffer defined by the first blank
;;      line before and after the current cursor position. Uses the
;;      `fancy-narrow' mode to high-light the block."
;;     (interactive)
;;     (let (cur beg end)
;;       (setq cur (point))
;;       (setq end (or (re-search-forward  "^\s*$" nil t) (point-max)))
;;       (goto-char cur)
;;       (setq beg (or (re-search-backward "^\s*$" nil t) (point-min)))
;;       (fancy-narrow-to-region beg end)
;;       (goto-char cur)))

;;   (defun ha/highlight-section (num)
;;     "If some of the buffer is highlighted with the `fancy-narrow'
;;      mode, then un-highlight it by calling `fancy-widen'.

;;      If region is active, call `fancy-narrow-to-region'.

;;      If NUM is 0, call `fancy-narrow-to-defun', to highlight
;;      current function. If NUM is 1, highlight the current
;;      block (delimited by blank lines). Otherwise, highlight that
;;      number of lines."
;;     (interactive "p")
;;     (cond
;;      ((fancy-narrow-active-p)  (fancy-widen))
;;      ((region-active-p)        (fancy-narrow-to-region (region-beginning) (region-end)))
;;      ((= num 0)                (fancy-narrow-to-defun))
;;      ((= num 1)                (ha/highlight-block))
;;      (t                        (progn (er/expand-region num) ; depend on `er/expand-region'
;;                                       (fancy-narrow-to-region (region-beginning) (region-end))
;;                                       (setq mark-active nil)))))

;;   ;; highlight-section is smart enough
;;   :bind (("C-x n ." . ha/highlight-section)))

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

(use-package smartscan
  :ensure t
  :bind
  ("M-n" . smartscan-symbol-go-forward)
  ("M-p" . smartscan-symbol-go-backward))

(use-package anzu
  :diminish anzu-mode
  :bind (("M-%" . anzu-query-replace)
         ("C-M-%" . anzu-query-replace-regexp))
  :config (global-anzu-mode))

(use-package visual-regexp
  :ensure t
  :init
  ;; use modern regular expressions instead of Emacs-style regular expressions
  (use-package visual-regexp-steroids :ensure t)

  :bind (("C-c r" . vr/replace)
         ("C-c q" . vr/query-replace))

  ;; if you use `multiple-cursors', this is for you:
  :config (use-package  multiple-cursors
            :bind ("C-c m" . vr/mc-mark)))

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

(delete-selection-mode t)

(use-package whitespace
  :bind ("C-c x w" . whitespace-mode)
  :diminish whitespace-mode
  :init
  ;; Indicate trailing empty lines in the GUI
  (set-default 'indicate-empty-lines t)
  (setq show-trailing-whitespace t)

  ;; limit line length                                                                    
  (setq whitespace-line-column 80)
  ;; Here are the things that whitespace-mode should highlight
  (setq whitespace-style '(face tabs empty trailing lines-tail))

  ;; Display pretty things for newlines and tabs (nothing for spaces)
  (setq whitespace-display-mappings
        ;; all numbers are Unicode codepoint in decimal. e.g. (insert-char 182 1)
        ;; 32 SPACE, 183 MIDDLE DOT
        '((space-mark nil)
          ;; 10 LINE FEED
          ;;(newline-mark 10 [172 10])
          (newline-mark nil)
          ;; 9 TAB, MIDDLE DOT
          (tab-mark 9 [183 9] [92 9])))

  ;; Disable it in certain modes where whitespace doesn't make sense.
  (setq whitespace-global-modes '(not org-mode
                                    eshell-mode
                                    shell-mode
                                    web-mode
                                    log4j-mode
                                    dired-mode
                                    emacs-lisp-mode
                                    clojure-mode
                                    lisp-mode)))

(use-package clean-aindent-mode
  :init
  (add-hook 'prog-mode-hook 'clean-aindent-mode))

(use-package smartparens
  :ensure t
  :defer t
  :diminish ""
  :init
  (smartparens-global-mode)
  (require 'smartparens-config))  

(use-package undo-tree
  :ensure t
  :diminish undo-tree-mode
  :init (global-undo-tree-mode)
  :config
  (progn
    (setq undo-tree-visualizer-timestamps t)
    (setq undo-tree-visualizer-diff t)))

(setq-default fill-column 79)
(add-hook 'text-mode-hook 'turn-on-auto-fill)
(add-hook 'prog-mode-hook 'turn-on-auto-fill)

(global-set-key (kbd "C-x t f") 'auto-fill-mode)
(global-set-key (kbd "C-x t t") 'toggle-truncate-lines)

(defun xah-unfill-paragraph ()
  "Replace newline chars in current paragraph by single spaces.
This command does the inverse of `fill-paragraph'."
  (interactive)
  (let ((fill-column most-positive-fixnum))
    (fill-paragraph)))

(define-key global-map "\M-Q" 'unfill-paragraph)

(setq hippie-expand-try-functions-list
 '(try-expand-dabbrev
   try-expand-dabbrev-all-buffers
   try-expand-dabbrev-from-kill
   try-complete-file-name-partially
   try-complete-file-name
   try-expand-all-abbrevs
   try-expand-list
   try-expand-line
   try-complete-lisp-symbol-partially
   try-complete-lisp-symbol))

(global-set-key (kbd "M-/") 'hippie-expand)

(use-package company
  :ensure t
  :diminish company-mode
  :bind ("C-:" . company-complete)  ; In case I don't want to wait
  :init
  (add-hook 'after-init-hook 'global-company-mode)
  :config
  (setq company-idle-delay 0.5)
  (setq company-show-numbers t)
  (setq company-tooltip-limit 10)
  (setq company-minimum-prefix-length 2)
  (setq company-tooltip-align-annotations t)
  ;; invert the navigation direction if the the completion popup-isearch-match
  ;; is displayed on top (happens near the bottom of windows)
  (setq company-tooltip-flip-when-above t))

(use-package company-quickhelp
  :ensure t
  :config
  (company-quickhelp-mode 1))

(use-package yasnippet
  :ensure
  :diminish t
  :init 
  (yas-global-mode 1)
  :config
  (add-to-list 'yas-snippet-dirs (expand-file-name "snippets" user-emacs-directory)))

brew install aspell

(use-package flyspell
  :defer t
  :diminish ""
  :init
  (add-hook 'prog-mode-hook 'flyspell-prog-mode)

  (dolist (hook '(text-mode-hook org-mode-hook))
    (add-hook hook (lambda () (flyspell-mode 1))))

  (dolist (hook '(change-log-mode-hook log-edit-mode-hook org-agenda-mode-hook))
    (add-hook hook (lambda () (flyspell-mode -1))))

  :config
  (setq ispell-program-name "/usr/local/bin/aspell" ; use aspell instead of ispell
        ispell-dictionary "american"
        ispell-extra-args '("--sug-mode=ultra"
                            "--lang=en_US"
                            "--ignore=3")
        ispell-list-command "--list"))

(global-set-key (kbd "C-x t s") 'flyspell-mode)

(use-package multiple-cursors
  :ensure t
  :bind (("C-c C-. ."   . mc/mark-all-dwim)
         ("C-c C-. C-." . mc/mark-all-like-this-dwim)
         ("C-c C-. n"   . mc/mark-next-like-this)
         ("C-c C-. C-n" . mc/mark-next-like-this)
         ("C-c C-. p"   . mc/mark-previous-like-this)
         ("C-c C-. C-p" . mc/mark-previous-like-this)
         ("C-c C-. a"   . mc/mark-all-like-this)
         ("C-c C-. C-a" . mc/mark-all-like-this)
         ("C-c C-. N"   . mc/mark-next-symbol-like-this)
         ("C-c C-. C-N" . mc/mark-next-symbol-like-this)
         ("C-c C-. P"   . mc/mark-previous-symbol-like-this)
         ("C-c C-. C-P" . mc/mark-previous-symbol-like-this)
         ("C-c C-. A"   . mc/mark-all-symbols-like-this)
         ("C-c C-. C-A" . mc/mark-all-symbols-like-this)
         ("C-c C-. f"   . mc/mark-all-like-this-in-defun)
         ("C-c C-. C-f" . mc/mark-all-like-this-in-defun)
         ("C-c C-. l"   . mc/edit-lines)
         ("C-c C-. C-l" . mc/edit-lines)
         ("C-c C-. e"   . mc/edit-ends-of-lines)
         ("C-c C-. C-e" . mc/edit-ends-of-lines)
         ("C-M-<mouse-1>" . mc/add-cursor-on-click)))

(use-package helm
  :ensure t
  :diminish ""
  :init
  (require 'helm)
  (require 'helm-config)

  ;; The default "C-x c" is quite close to "C-x C-c", which quits Emacs.
  ;; Changed to "C-c h". Note: We must set "C-c h" globally, because we
  ;; cannot change `helm-command-prefix-key' once `helm-config' is loaded.
  (global-set-key (kbd "C-c h") 'helm-command-prefix)
  (global-unset-key (kbd "C-x c"))

  ;; rebind tab to run persistent action
  (define-key helm-map (kbd "<tab>") 'helm-execute-persistent-action)
  ;; make TAB works in terminal
  (define-key helm-map (kbd "C-i") 'helm-execute-persistent-action)
  ;; list actions using C-z
  (define-key helm-map (kbd "C-z")  'helm-select-action)

  (when (executable-find "curl")
    (setq helm-google-suggest-use-curl-p t))

  (setq helm-split-window-in-side-p           t
        helm-move-to-line-cycle-in-source     t
        helm-ff-search-library-in-sexp        t
        helm-scroll-amount                    8
        helm-ff-file-name-history-use-recentf t)

  (helm-mode 1)

  :config
  ;; fuzzy matching
  (setq helm-recentf-fuzzy-match t
        helm-locate-fuzzy-match nil ;; locate fuzzy is worthless
        helm-M-x-fuzzy-match t
        helm-buffers-fuzzy-matching t
        helm-semantic-fuzzy-match t
        helm-apropos-fuzzy-match t
        helm-imenu-fuzzy-match t
        helm-lisp-fuzzy-completion t
        helm-completion-in-region-fuzzy-match t)

  :bind (("M-x" . helm-M-x)
         ("M-y" . helm-show-kill-ring)

         ("C-x b" . helm-mini)
         ("C-x C-b" . helm-buffers-list)
         ("C-x C-f" . helm-find-files)
         ("C-x C-r" . helm-recentf)

         ("C-c s" . helm-swoop)
         ("C-c o" . helm-occur)

         ("C-c h a" . helm-apropos)
         ("C-c h y" . helm-yas-complete)
         ("C-c h SPC" . helm-all-mark-rings)
         ("C-c h i" . helm-semantic-or-imenu)
         ("C-c h m" . helm-man-woman)
         ))

  (use-package helm-projectile
    :bind ("C-x p h" . helm-projectile)
    :init (projectile-global-mode)
    :config
    (helm-projectile-on)
    (setq projectile-completion-system 'helm)
    ;(setq projectile-switch-project-action 'helm-projectile-find-file)
)

(use-package helm-swoop
  :bind (("M-i" . helm-swoop)
         ("M-I" . helm-swoop-back-to-last-point)
         ("C-c M-i" . helm-multi-swoop))
  :config
  ;; When doing isearch, hand the word over to helm-swoop
  (define-key isearch-mode-map (kbd "M-i") 'helm-swoop-from-isearch)
  ;; From helm-swoop to helm-multi-swoop-all
  (define-key helm-swoop-map (kbd "M-i") 'helm-multi-swoop-all-from-helm-swoop)
  ;; Save buffer when helm-multi-swoop-edit complete
  (setq helm-multi-swoop-edit-save t
        ;; If this value is t, split window inside the current window
        helm-swoop-split-with-multiple-windows t
        ;; Split direcion. 'split-window-vertically or 'split-window-horizontally
        helm-swoop-split-direction 'split-window-vertically
        ;; If nil, you can slightly boost invoke speed in exchange for text color
        helm-swoop-speed-or-color nil))

(use-package helm-descbinds
  :bind ("C-h b" . helm-descbinds)
  :init (fset 'describe-bindings 'helm-descbinds)
  :config (require 'helm-config))

(use-package helm-flyspell
  :defer t
  :config
  (define-key flyspell-mode-map (kbd "M-S") 'helm-flyspell-correct))

(require 'recentf)
(recentf-mode 1) ; keep a list of recently opened files, for future sessions
(setq recentf-save-file (expand-file-name "recentf" user-emacs-savefile-dir))

(setq recentf-max-saved-items 500
      recentf-max-menu-items 25
      ;; disable recentf-cleanup on Emacs start, because it can cause
      ;; problems with remote files
      recentf-auto-cleanup 'never)

(global-set-key (kbd "C-c f r") 'recentf-open-files)

(require 'saveplace)
(save-place-mode 1)
(setq save-place-file (expand-file-name "saveplace" user-emacs-savefile-dir))

(require 'savehist)
(savehist-mode 1)
(setq savehist-file (expand-file-name "savehist" user-emacs-savefile-dir))

(setq history-length t)
(setq history-delete-duplicates t)
(setq savehist-save-minibuffer-history 1)
(setq savehist-additional-variables
      '(kill-ring
        search-ring
        regexp-search-ring))

(require 'desktop)
(desktop-save-mode 1)
(setq desktop-base-file-name (expand-file-name "desktop" user-emacs-savefile-dir))
(setq desktop-base-lock-name (expand-file-name "desktop.lock" user-emacs-savefile-dir))

(setq desktop-save 'ask)
(setq desktop-auto-save-timeout nil)

(require 'bookmark)
(setq bookmark-default-file (expand-file-name "bookmark" user-emacs-savefile-dir))
(setq bookmark-save-flag 1) ; everytime bookmark is changed, auto save it

(require 'eshell)
(setq eshell-directory-name (expand-file-name "eshell" user-emacs-savefile-dir))

(global-set-key [f8] 'other-frame)
(global-set-key [f9] 'enlarge-window)
(global-set-key [f10] 'enlarge-window-horizontally)
(global-set-key [f11] 'toggle-frame-fullscreen)

(global-set-key (kbd "s-0") 'delete-window)
(global-set-key (kbd "s-1") 'delete-other-windows)
(global-set-key (kbd "s-2") 'split-window-below)
(global-set-key (kbd "s-3") 'split-window-right)

(global-set-key (kbd "C-s-=") 'text-scale-increase)
(global-set-key (kbd "C-s--") 'text-scale-decrease)

(define-prefix-command 'endless/toggle-map)
;; The manual recommends C-c for user keys, but C-x t is
;; always free, whereas C-c t is used by some modes.
(define-key ctl-x-map "t" 'endless/toggle-map)
;; build-in packages
(define-key endless/toggle-map "d" #'toggle-debug-on-error)
(define-key endless/toggle-map "q" #'toggle-debug-on-quit)
(define-key endless/toggle-map "f" #'auto-fill-mode)
(define-key endless/toggle-map "t" #'toggle-truncate-lines)
(define-key endless/toggle-map "l" #'display-line-numbers-mode)
;; packages installed by `use-packages'
(define-key endless/toggle-map "w" #'whitespace-mode)
(define-key endless/toggle-map "s" #'flyspell-mode)
(define-key endless/toggle-map "c" #'flycheck-mode)
(define-key endless/toggle-map "g" #'git-timemachine)

;; Align your code in a pretty way.
(global-set-key (kbd "C-x \\") 'align-regexp)

;; Start eshell or switch to it if it's active.
(global-set-key (kbd "C-x m") 'eshell)

;; Start a new eshell even if one is active.
(global-set-key (kbd "C-x M") (lambda () (interactive) (eshell t)))

;; Start a regular shell if you prefer that.
(global-set-key (kbd "C-x M-m") 'shell)

;; use hippie-expand instead of dabbrev
(global-set-key (kbd "M-/") 'hippie-expand)

;; replace buffer-menu with ibuffer
(global-set-key (kbd "C-x C-b") 'ibuffer)

(use-package which-key
  :ensure t
  :config (which-key-mode))

(use-package aggressive-indent
  :init (global-aggressive-indent-mode 1))

(use-package indent-guide
  :init (indent-guide-global-mode))

(defun ha/hs-show-all ()
  (interactive)
  (hs-minor-mode 1)
  (hs-show-all))

(defun ha/hs-hide-all ()
  (interactive)
  (hs-minor-mode 1)
  (hs-hide-all))

(defun ha/hs-toggle-hiding ()
  (interactive)
  (hs-minor-mode 1)
  (hs-toggle-hiding))

(global-set-key (kbd "C-x t h") 'hs-minor-mode)
(global-set-key (kbd "C-c t h") 'ha/hs-hide-all)
(global-set-key (kbd "C-c t s") 'ha/hs-show-all)
(global-set-key (kbd "C-c t c") 'ha/hs-toggle-hiding)