[ardggy] init.el for GNU Emacs

init.el

;;; -*- mode: emacs-lisp -*-
;;; .emacs
(eval-when-compile
  (require 'cl-lib))

(setq gc-cons-threshold (* 128 1024 1024))
(setq garbage-collection-messages t)

(when (require 'server nil t)
  (unless (server-running-p)
    (server-start)))

;; Added by Package.el.  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.
(when (require 'package nil t)
  (setq package-archives
        '(("gnu" . "http://elpa.gnu.org/packages/")
          ("melpa" . "http://melpa.org/packages/")
          ("org" . "http://orgmode.org/elpa/")))
  (package-initialize)
)

(unless (package-installed-p 'benchmark-init)
  (package-install 'benchmark-init))

(when (and nil (require 'benchmark-init nil t))
  (add-hook 'after-init-hook 'benchmark-init/deactivate))

(add-hook 'after-init-hook
          (lambda ()
            (call-interactively 'emacs-init-time)))

(setq scroll-step 1
      scroll-conservatively 50
      scroll-margin 0)

;; (setq initial-major-mode 'emacs-lisp-mode)

(setq byte-compile-warnings '(not free-vars obsolete make-local interactive-only unresolved))
(setq confirm-kill-emacs 'y-or-n-p)

(with-eval-after-load "init"
  (global-set-key (kbd "C-h") #'delete-backward-char)
  (global-set-key (kbd "M-h") #'backward-kill-word)
  (global-set-key (kbd "M-?") #'help)
  (global-set-key (kbd "M-ESC ESC") #'keyboard-quit))

(when load-file-name
  (setq user-emacs-directory (file-name-directory load-file-name)))

(unless (require 'use-package nil t)
  (package-install 'use-package))

;; theme
(add-hook 'window-setup-hook #'my-theme)
(add-hook 'window-setup-hook #'title-bar)

(when (eval-when-compile (eq window-system 'ns))
  (add-to-list 'default-frame-alist '(ns-transparent-titlebar . t))
  (add-to-list 'default-frame-alist '(ns-appearance . dark)))

(defun title-bar ()
  (setq
   frame-title-format
   '("" global-mode-string (:eval (if (buffer-file-name) " %f" "  %b")))))

(defun my-theme ()
  (load-theme 'atom-one-dark t))

(use-package atom-one-dark-theme
  :no-require t
  :ensure t :pin melpa
  :defer t
  :commands (atom-one-dark)
)

;;; init.elc
;; Compile on kill-emacs
;; Delete `init.elc' after init
(add-hook 'kill-emacs-hook 'byte-compile-init-file)
(add-hook 'after-init-hook 'delete-compiled-init-file)

(defun byte-compile-init-file ()
  (interactive)
  (byte-compile-file (locate-user-emacs-file "init.el")))

(defun delete-compiled-init-file ()
  (interactive)
  (when (file-writable-p (locate-user-emacs-file "init.elc"))
    (delete-file (locate-user-emacs-file "init.elc") nil)))

;; last-frame
(add-hook 'after-init-hook #'load-last-frame)
(add-hook 'kill-emacs-hook #'save-last-frame)

(defvar last-frame-file "last-frame-alist.el")
(defvar last-frame-properties '(top left width height))

(defun save-last-frame ()
  (let ((file (locate-user-emacs-file last-frame-file)))
    (with-temp-buffer
      (erase-buffer)
      (setq-local buffer-file-coding-system 'utf-8)
      (let ((parameters (frame-parameters)))
        (pp (mapcar (lambda (key) (assoc key parameters))
                    last-frame-properties)
            (current-buffer))
        (insert "\n")
        (write-file file nil)))))

(defun load-last-frame ()
  (let ((file (locate-user-emacs-file last-frame-file)))
    (when (file-readable-p file)
      (with-temp-buffer
        (erase-buffer)
        (insert-file-contents file)
        (let ((parameters (read (current-buffer))))
          (modify-frame-parameters nil parameters)
          (setq initial-frame-alist (append parameters initial-frame-alist))
          ;; (setq default-frame-alist initial-frame-alist)
          )))))

(use-package hideshow
  :no-require t
  :defer t
  :init (add-hook 'prog-mode-hook 'hs-minor-mode)
  :config
  (define-key hs-minor-mode-map (kbd "C-c [ [") #'hs-toggle-hiding)
  (define-key hs-minor-mode-map (kbd "C-c [ h") #'hs-hide-block)
  (define-key hs-minor-mode-map (kbd "C-c [ s") #'hs-show-block)
  (define-key hs-minor-mode-map (kbd "C-c [ l") #'hs-hide-level)
  (define-key hs-minor-mode-map (kbd "C-c [ M-h") #'hs-hide-all)
  (define-key hs-minor-mode-map (kbd "C-c [ M-s") #'hs-show-all)

  (let ((ruby-mode-hs-info
         '(ruby-mode
           "class\\|module\\|def\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin\\|do"
           "end"
           "#"
           ruby-move-to-block
           nil)))
    (unless (member ruby-mode-hs-info hs-special-modes-alist)
      (add-to-list 'hs-special-modes-alist ruby-mode-hs-info)))
  )

(use-package display-line-numbers
  :no-require t
  :defer t
  :init (add-hook 'emacs-startup-hook 'global-display-line-numbers-mode)
  :config
  (custom-set-variables '(display-line-numbers-width 4)))

(with-eval-after-load "python"
  (defun python-shell-parse-command () "python3 -i"))

(use-package highlight-symbol
  :no-require t
  :ensure t :pin melpa
  :defer t
  :commands (highlight-symbol-mode)
  :init
  (run-at-time 1.5 nil 'require 'highlight-symbol)
  (add-hook 'prog-mode-hook #'highlight-symbol-mode)
  (add-hook 'prog-mode-hook #'highlight-symbol-nav-mode)
  :config
  (setq highlight-symbol-idle-delay 0.75)
  (set-face-attribute 'highlight-symbol-face nil :foreground "yellow")

  )

(use-package dimmer
  :no-require t
  :ensure t :pin melpa
  :defer t
  :commands (dimmer-mode)
  :init
  (add-hook 'emacs-startup-hook #'dimmer-mode)
  :config)

(use-package rainbow-delimiters
  :no-require t
  :ensure t :pin melpa
  :commands (rainbow-delimiters-mode)
  :defer t
  :init (run-with-idle-timer 1.5 nil #'rainbow-delimiters-mode)
  :config
  )

(defadvice mark-word (before mark-word-around activate)
  "mark, around word."
  (beginning-of-thing 'word))

(defadvice subword-mark (before mark-subword-around activate)
  "mark, around subword."
  (let ((prev-forward-op (get 'word 'forward-op)))
    (put 'word 'forward-op 'subword-forward)
    (beginning-of-thing 'word)
    (put 'word 'forward-op prev-forward-op)))

(use-package csv-mode
  :no-require t
  :ensure t :pin gnu
  :defer t
  :commands (csv-mode)
  :mode (("\\.csv$" . csv-mode))
  :config
  (add-hook 'csv-mode-hook #'csv-mode-config))

(defun csv-mode-config ()
  (setq-local csv-header-lines 1)
  (setq-local require-final-newline nil))

(use-package exec-path-from-shell
  :no-require t
  :ensure t :pin melpa
  :init
  (run-at-time 0.25 nil #'exec-path-from-shell-initialize)
  :config
  (setq exec-path-from-shell-check-startup-files nil))

(use-package editorconfig
  :ensure t
  :if nil
  :commands (editorconfig-mode)
  :after (exec-path-from-shell)
  :defer t
  :init
  (run-with-idle-timer 2.5 nil 'require 'editorconfig)
)

(use-package popwin
  :no-require t
  :ensure t :pin melpa
  :commands (popwin-mode)
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'popwin-mode)
  )

(use-package ggtags
  :no-require t
  :ensure t :pin melpa
  :defer t
  :init
  (add-hook 'c-mode-hook 'ggtags-mode)
  (add-hook 'cc-mode-hook 'ggtags-mode)
  (add-hook 'php-mode-hook 'ggtags-mode)
  :config
  (setq-default ggtags-enable-navigation-keys nil)
  (setq ggtags-enable-navigation-keys nil)
)

(use-package ido
  :no-require t
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'ido-mode)
  :config
  (define-key ido-common-completion-map (kbd "C-n") 'ido-next-match)
  (define-key ido-common-completion-map (kbd "C-p") 'ido-prev-match)
  (setq ido-enable-flex-matching t)
  (setq ido-everywhere t)
  )

(use-package ido-completing-read+
  :ensure t :pin melpa
  :after ido
  :config
  (ido-ubiquitous-mode))

(use-package smex
  :no-require t
  :ensure t :pin melpa
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'smex-initialize)
  :config
  (global-set-key (kbd "M-x") 'smex)
  (global-set-key (kbd "M-X") 'smex-major-mode-commands)
  (global-set-key (kbd "C-c M-x") 'execute-extended-command)
  )

(use-package vc
  :no-require t
  :defer t
  :config
  (setq vc-follow-symlinks t)
  (setq vc-diff-switches '("-Bbu")))

(defun vc-mode-when-responsible ()
  (interactive)
  (when (ignore-errors
         (vc-responsible-backend (buffer-file-name)))
    (vc-mode)))

(use-package magit
  :disabled
  :after (exec-path-from-shell)
  :no-require t
  :ensure t :pin melpa
  :defer t
  :config
  (setq magit-diff-refine-hunk 'all)
  (setq magit-auto-revert-mode t)
  (setq smerge-refine-ignore-whitespace nil))

(use-package flymake
  :no-require t
  :commands (flymake-mode)
  :defer t
  :config
  (unless (eval-when-compile (eq system-type 'windows-nt))
    (add-hook 'c-mode-common-hook 'flymake-mode))
  )

(use-package flymake-cursor
  :no-require t
  :ensure t
  :require flymake
  :disabled)

(defun c-stroustrup-style ()
  (c-set-style "stroustrup"))

(use-package cc-mode
  :no-require t
  :ensure t :pin manual
  :commands (cc-mode)
  :defer t
  :init
  :config
  (add-hook 'c-mode-hook 'c-stroustrup-style)
  (add-hook 'c-mode-hook 'c-mode-indent)
  )

(defun c-mode-indent ()
  (setq-local tab-width 4)
  (setq-local indent-tabs-mode nil)
  (setq-local require-final-newline t)
  (setq-local c-basic-offset 4))

(setq php-doc-directory (concat (getenv "HOME") "/Documents/php-chunked-xhtml"))
(defun php-mode-doc ()
  (setq-local eldoc-documentation-function 'php-doc-eldoc-function))

(defun php-mode-indent ()
  (setq-local c-basic-offset 4)
  (setq-local indent-tabs-mode nil)
  (setq-local tab-width 4)
  (setq-local require-final-newline t))

(use-package php-mode
  :no-require t
  :ensure t :pin melpa
  :defer t
  :mode (("\\.php$" . php-mode))
  :init
  (run-at-time 4.0 nil 'require 'php-mode)
  :config
    (add-hook 'php-mode-hook 'auto-revert-mode)
    (add-hook 'php-mode-hook 'editorconfig-mode)
    (add-hook 'php-mode-hook 'hs-minor-mode)
    (add-hook 'php-mode-hook 'prettify-symbols-mode)
    (add-hook 'php-mode-hook 'rainbow-delimiters-mode)
    (add-hook 'php-mode-hook 'show-paren-mode) ;(
    (add-hook 'php-mode-hook 'subword-mode)
    (add-hook 'php-mode-hook 'which-function-mode)
    (add-hook 'php-mode-hook 'php-enable-default-coding-style)
    (add-hook 'php-mode-hook 'php-mode-indent)
    (when (eval-when-compile (executable-find "php"))
      ;; (add-hook 'php-mode-hook 'flymake-mode)
      ;; (add-hook 'php-mode-hook 'flymake-php-init)
    )
    ;; (add-hook 'php-mode-hook 'php-eldoc-enable) ;; depend on `auto-complete-mode'
    )

(defun web-mode-hook ()
  (setq-local indent-tabs-mode nil)
  (setq-local web-mode-markup-indent-offset 2)
  (setq-local web-mode-script-padding 0)
  (setq-local web-mode-style-padding 0)
  (setq-local web-mode-css-indent-offset 2)
  (setq-local web-mode-enable-css-colorization t)
  (setq-local web-mode-enable-current-element-highlight t)
  (web-mode-set-engine 'django)
  )

(use-package web-mode
  :no-require t
  :ensure t :pin melpa
  :defer t
  :mode (("\\.tpl$" . web-mode)
         ("views?/\\(?:../\\)*.*\\.php$" . web-mode)
         ("\\.html$" . web-mode)
         ("\\.twig$" . web-mode))
  :init (run-at-time 5.0 nil 'require 'web-mode)
  :config
  (add-hook 'web-mode-hook 'web-mode-hook)
  (add-hook 'web-mode-hook 'hs-minor-mode)
  )

(use-package whitespace
  :no-require t
  :commands (whitespace-mode)
  :defer t
  :init
  (add-hook 'after-change-major-mode-hook 'whitespace-mode)
  (add-hook 'before-save-hook 'delete-trailing-whitespace)
  :config
  (setq-default show-trailing-whitespace t)
  (setq whitespace-style '(face spaces space-mark tabs tab-mark newline newline-mark))
  (setq whitespace-space-regexp "\\(\u3000+\\)")
  (setq whitespace-display-mappings
        '((space-mark ?\u3000 [?\u25a1])
          (tab-mark ?\t [?\u00BB ?\t])
          (newline-mark ?\n [?\u21B2 ?\n])))
  (set-face-attribute 'whitespace-tab nil
                      :foreground "grey22")
  (set-face-attribute 'whitespace-newline nil
                      :foreground "slate grey")
  (set-face-attribute 'whitespace-space nil
                      :foreground "green" :bold t)
)

(use-package projectile
  :no-require t
  :ensure t :pin melpa
  :defer t
  :init (run-at-time 2.0 nil 'require 'projectile)
  :config
  (projectile-mode)
  (define-key global-map (kbd "C-c p") projectile-command-map)
  (setq projectile-enable-caching nil)
  (setq projectile-indexing-method (eval-when-compile (if (eq system-type 'windows-nt) 'native 'alien)))
  (setq projectile-file-exists-local-cache-expire nil)
  (setq projectile-mode-line '(:eval (format " Pj[%s]" (projectile-project-name))))
  ;; require ggtags-mode
  ;; (setq projectile-tags-command "gtags -qi")
  ;; (setq projectile-tags-file-name "GTAGS")

  (when (featurep 'perspective)
    (require 'persp-projectile))

  (add-hook 'projectile-mode-hook 'auto-revert-mode)
  )

(use-package ggtags
  :no-require t
  :after projectile
  :ensure t :pin melpa
  :defer t
  :init (add-hook 'projectile-mode-hook 'ggtags-mode)
)

(with-eval-after-load "sql"
  (sql-set-product 'mysql)
)

(defun my-sql-indent ()
  (setq-local sql-indent-offset 2)
  (setq-local sql-indent-maybe-tab nil))

(defun mysql-syntax ()
  (setq-local syntax-propertize-function 'mysql-syntax-propertize-function)
  )

(defun mysql-syntax-propertize-function (begin end)
  (funcall
   (syntax-propertize-rules
    ("\\(#\\).*\\(\n\\)" (1 "<") (2 ">")))
   begin
   end))

(setq-default indicate-buffer-boundaries '((top . left) (t . left)))

(setq inhibit-startup-screen t)
(setq-default require-final-newline t)

(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
(setq visible-bell nil)
(setq ring-bell-function 'ignore)
(setq initial-scratch-message "")
(when window-system
  (run-at-time 0.125 nil 'scroll-bar-mode -1))

;;; on Mac OS X
;; $ defaults write org.gnu.Emacs ToolBar -string no
;; $ defaults write org.gnu.Emacs MenuBar -string no
;; (run-with-idle-timer 0.5 nil 'tool-bar-mode -1)
(run-at-time 0.5 nil 'menu-bar-mode -1)

(set-language-environment "Japanese")
(set-locale-environment "ja_JP.UTF-8")
(setq system-time-locale "C")

;; (setq default-process-coding-system 'utf-8-unix)
;; (setq default-buffer-file-coding-system 'utf-8-unix)
(prefer-coding-system 'utf-8-unix)

(setq eol-mnemonic-dos "(CRLF)")
(setq eol-mnemonic-mac "(CR)")
(setq eol-mnemonic-unix "(LF)")

(when (eval-when-compile (eq window-system 'ns))
  (set-file-name-coding-system 'utf-8-hfs))

(when (eval-when-compile (eq system-type 'windows-nt))
  (prefer-coding-system 'japanese-cp932)     ; third
  (prefer-coding-system 'euc-jp)             ; second (alias of japanese-iso-8bit)
  (prefer-coding-system 'utf-8-unix)         ; first

  ;; priority list -> (coding-system-priority-list)
  (setq default-process-coding-system '(cp932-dos . cp932-dos))
  (set-terminal-coding-system 'cp932-dos)
  (set-file-name-coding-system 'cp932-dos)
  )

(global-set-key (kbd "M-s %") 'replace-string)

(use-package git-gutter-fringe+
  :no-require t
  :when window-system
  :ensure t :pin melpa
  :commands (git-gutter+-enable-fringe-display-mode)
  :defer t
  :init (add-hook 'prog-mode-hook 'git-gutter+-enable-fringe-display-mode)
  )

(use-package fringe-current-line
  :no-require t
  :when window-system
  :ensure t :pin melpa
  :defer t
  :commands (global-fringe-current-line-mode)
  :init (add-hook 'emacs-startup-hook 'global-fringe-current-line-mode)
  )

(defun vc-svn-coding-system ()
  (when (eval-when-compile (eq system-type 'windows-nt))
    (setq-local buffer-file-coding-system 'cp932-dos)))

(with-eval-after-load "vc"
  (setf vc-make-backup-files nil)
  (when (featurep 'popwin)
    (push '("\\*Annotate.*\\*" :regexp t) popwin:special-display-config)
    (push '"*vc*" popwin:special-display-config)
    )
  (when (eval-when-compile (and t (eq system-type 'windows-nt)))
    (add-to-list 'process-coding-system-alist '("[sS][vV][nN]" . (cp932-dos . cp932-dos)))))


(use-package paren
  :defer t
  :init (add-hook 'after-init-hook 'show-paren-mode)
  :config
  (setf blink-matching-paren t)
  (setf blick-matching-delay 1)
  (setf blink-matching-paren-distance 102400))

(use-package elec-pair
  :no-require t
  :init (run-at-time 0.5 nil 'electric-pair-mode -1)
  :defer t
)

(setf use-dialog-box nil)
(setf auto-save-default t)
(setq-default make-backup-files nil)
(setq backup-inhibited t)

(with-eval-after-load 'prog-mode
  (push '("<=" . ?≦) prettify-symbols-alist)
  (push '(">=" . ?≧) prettify-symbols-alist)
  (push '("!=" . ?≠) prettify-symbols-alist)
  )

(with-eval-after-load 'lisp-mode
  (add-hook 'lisp-mode-hook 'check-parens-before-save))

(with-eval-after-load 'elisp-mode
  (add-hook 'emacs-lisp-mode-hook 'hs-minor-mode)
  ;; (add-hook 'emacs-lisp-mode-hook 'prettify-symbols-mode)
  (add-hook 'emacs-lisp-mode-hook 'el-prettify-symbol)
  (add-hook 'emacs-lisp-mode-hook 'superword-mode)
  ;; (add-hook 'emacs-lisp-mode-hook 'flymake-mode)
  (add-hook 'emacs-lisp-mode-hook 'eldoc-mode)
  (add-hook 'emacs-lisp-mode-hook 'highlight-symbol-mode)
  ;; (add-hook 'emacs-lisp-mode-hook 'find-function-setup-keys)
  (add-hook 'emacs-lisp-mode-hook 'auto-revert-mode)
  (add-hook 'emacs-lisp-mode-hook 'el-config)
  (add-hook 'emacs-lisp-mode-hook 'check-parens-before-save)
  )

(defun el-prettify-symbol ()
  (make-local-variable 'prettify-symbols-alist)
  (push '("<=" . ?≦) prettify-symbols-alist)
  (push '(">=" . ?≧) prettify-symbols-alist)
  (push '("lambda" . ?λ) prettify-symbols-alist)
  )

(defun el-config ()
  (setq-local mode-name "el")
  (setq-local lisp-indent-offset nil)
  (setq-local indent-tabs-mode nil)
  )

(defun check-parens-before-save ()
  "Run `check-parens' function before saving a buffer."
  (add-hook 'write-contents-functions 'check-parens nil t))

;; scheme
(autoload 'gauche-manual "gauche-manual" t)
(setq browse-url-browser-function 'eww-browse-url)
(use-package cmuscheme
  :mode (("\\.scm$" . scheme-mode))
  :defer t
  :init
  :config
  (add-to-list 'process-coding-system-alist '("gosh" utf-8-unix . utf-8-unix))
  (add-hook 'scheme-mode-hook 'fontify-gauche-regexp-literal)
  (add-hook 'scheme-mode-hook 'gauche-syntax)
  (add-hook 'scheme-mode-hook 'check-parens-before-save)
  (setq scheme-program-name "gosh -i")
  ;; (define-key inferior-scheme-mode-map (kbd "M-g i") 'gauche-manual)
  )

;;; from shiro
(defun gauche-info-index (topic)
  (interactive
   (list (read-string (concat "Gauche help topic : ") (current-word))))
  (switch-to-buffer-other-window (get-buffer-create "*info*"))
  (info "/usr/local/share/info/gauche-refe.info.gz")

  (Info-index topic))

(defun gauche-syntax ()
  (setq-local syntax-propertize-function 'gauche-syntax-propertize-function)
  )

(defun gauche-syntax-propertize-function (start end)
  (let ((case-fold-search nil))
    (goto-char start)
    (funcall
     (syntax-propertize-rules
      ("#/.*?/i?" (0 "."))
      ("\\(#\\);" (1 (prog1 "< cn"
                       (scheme-syntax-propertize-sexp-comment (point) end)))))
     (point) end)))

(defun fontify-gauche-regexp-literal ()
  (font-lock-add-keywords 'scheme-mode
                          '(("#/.*?/"  (0 font-lock-builtin-face t))
                            (",|.*?|" (0 font-lock-variable-name-face t))
                            )))

;; (define-key key-translation-map [?\C-h] [?\C-?])

(defun minibuffer-delete-backward-char ()
  (local-set-key (kbd "C-h") 'delete-backward-char))

(add-hook 'minibuffer-setup-hook 'minibuffer-delete-backward-char)
(define-key minibuffer-local-map (kbd "C-p") 'previous-history-element)
(define-key minibuffer-local-map (kbd "C-n") 'next-history-element)
(define-key minibuffer-local-map (kbd "C-h") 'delete-backward-char)
(define-key isearch-mode-map (kbd "C-h") 'isearch-delete-char)
(define-key global-map (kbd "C-M-s") 'isearch-forward-symbol-at-point)

(defun my-org-mode-locale ()
  "Change `system-time-locale' locally in org-mode."
  (setq-local system-time-locale "C")
  )

(defun my-org-timestamp-hook ()
  "Change `time-stamp-start' in org-mode"
  (setq-local time-stamp-start "#\\+DATE: 2")
  (setq-local time-stamp-end "\$")
  )

(defun org-capture-journal-filename ()
  (format-time-string "~/org/journal/%Y%m%d.org"))

(use-package org
  :disabled nil
  :commands (org-mode)
  :defer t
  :mode ((".notes" . org-mode) ("\\.txt$" . org-mode))
  :config
  (setq org-agenda-sticky t)
  (setq org-directory (expand-file-name "~/org"))
  (setq org-journal-dir "~/org/journal")

  (setq org-agenda-file-regexp "201[56].*\\.org")
  (setq org-agenda-files '("~/org/gtd.org" "~/org/journal" "~/org/done.org" "~/org/games.org"))

  (setq org-default-notes-file (expand-file-name "~/org/journal.org"))
  (setq org-agenda-span 'day)
  (setq org-time-stamp-custom-formats org-display-custom-times)
  (setq org-agenda-time-leading-zero t)

  (setq org-log-done t)
  (setq org-todo-keywords
        '("INBOX(i)" "TODO(t)" "PROGRESS(i)" "WAIT(w)" "|" "DONE(d)" "SOMEDAY(s)"))
  (setq org-capture-templates
        '(
          ("m" "Memo" entry (file (org-capture-journal-filename))
           "* %T %?"
           )
          ("t" "TODO" entry (file "~/org/gtd.org")
           "* INBOX %?\n  - %u\n"
           )
          ("r" "REST" entry (file (org-capture-journal-filename))
           "* %T トイレ")
          ("c" "Cach" plain (file "~/org/2016.lgr")
           "\n%<%Y-%m-%d> %^{Payee}
    %^{Account}                    %^{Amount}
    %^{Debit}")
          ))

  (setq org-refile-targets '(("~/org/gtd.org" :maxlevel . 1)))

  (global-set-key (kbd "C-c o l") 'org-store-link)
  (global-set-key (kbd "C-c o c") 'org-capture)
  (global-set-key (kbd "C-c o a") 'org-agenda)
  (global-set-key (kbd "C-c o b") 'org-iswitchb)

  (add-hook 'org-mode-hook 'my-org-mode-locale)
  (add-hook 'org-mode-hook 'my-org-timestamp-hook)

  (with-eval-after-load 'popwin
    (push '(org-mode) popwin:special-display-config)
    (push '(org-agenda-mode) popwin:special-display-config)
    (push '("\\.org$" :regexp t) popwin:special-display-config)
    (push '("^CAPTURE-.+\\*.org$" :regexp t) popwin:special-display-config)
    (push "*Shell Command Output*" popwin:special-display-config)
    (push "*Org Agenda*" popwin:special-display-config)
    (push "*Org Agenda(a)*" popwin:special-display-config)
    (push "*Agenda Commands*" popwin:special-display-config)
    (push "*Pp Macroexpand Output*" popwin:special-display-config)
    )
  )

(defun sh-mode-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local sh-indentation 2)
  (setq-local sh-basic-offset 2)
  )

(with-eval-after-load "sh-script"
  (add-hook 'sh-mode-hook 'sh-mode-indent)
  (set-face-attribute 'sh-heredoc nil :foreground "lightgreen" :bold nil)
)

(with-eval-after-load 'saveplace
  (progn
    (setq-default save-place t)))

;; instead of 'abort-recursive-edit' (C-x X a)
;; (add-hook 'find-file-hook 'view-mode)
(add-hook 'find-function-after-hook 'find-el-hook)
(add-hook 'xref-after-jump-hook 'find-el-hook)

(with-eval-after-load "mule-cmd"
  (define-key global-map (kbd "C-\\") 'view-mode)
)

(with-eval-after-load "view"
  (define-key view-mode-map (kbd "e") nil)
  (define-key view-mode-map (kbd "E") nil)
  ;; (global-set-key (kbd "C-x C-q") nil)
  ;; (global-set-key (kbd "C-x C-q") 'view-mode)
  )

(defun find-el-hook ()
  (when (or
         (string-suffix-p ".el.gz" (buffer-file-name))
         (string-suffix-p ".el" (buffer-file-name)))
    (view-mode 1)))

(define-key global-map (kbd "C-]") 'top-level)
; (mouse-avoidance-mode 'none)

(defun ime-cursor-color ()
  (set-cursor-color "yellow"))

(defun normal-cursor-color ()
  (set-cursor-color "white"))

(add-hook 'input-method-activate-hook 'ime-cursor-color)
(add-hook 'input-method-deactivate-hook 'normal-cursor-color)

(global-unset-key (kbd "C-x o"))
(global-set-key (kbd "C-x <up>") 'windmove-up)
(global-set-key (kbd "C-x <down>") 'windmove-down)
(global-set-key (kbd "C-x <right>") 'windmove-right)
(global-set-key (kbd "C-x <left>") 'windmove-left)
(global-set-key (kbd "C-x C-n") 'other-window)
(global-set-key (kbd "C-x C-p") (lambda () (interactive) (other-window -1)))

(with-eval-after-load "grep"
  (grep-apply-setting 'grep-find-use-xargs 'gnu)
  ;; ignore binary
  (grep-apply-setting 'grep-find-command "find . -type f -print0 | xargs -0 grep --null -nIH -E ")
  ;; (grep-apply-setting 'grep-find-template "find <D> <X> -type f <F> -print0 | xargs -0 grep <C> -nIH --null -E <R>")
  (grep-apply-setting 'grep-command "grep  -nIH --null -E ")
  ;; (grep-apply-setting 'grep-template "grep <X> <C> -n --null -e <R> <F>")
  (define-key global-map (kbd "M-s g") 'grep)
  (define-key global-map (kbd "M-s f") 'find-grep))

(with-eval-after-load "find-dired"
  (setq find-ls-option '("-exec ls -ldh {} +" . "-ldh"))
)

;; M-g prefixed
(define-key goto-map (kbd "l") 'find-library)
(define-key goto-map (kbd "f") 'find-function-at-point)
(define-key goto-map (kbd "v") 'find-variable-at-point)

(use-package migemo
  ;; :no-require t
  :ensure t
  :after (exec-path-from-shell)
  :when (eval-when-compile (executable-find "cmigemo"))
  :commands (migemo-init)
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'migemo-init)
  :config
  (setq migemo-command "cmigemo")
  (setq migemo-options '("-q" "--emacs"))
  (setq migemo-dictionary
        (eval-when-compile
          (cond ((eq system-type 'windows-nt)
                 (expand-file-name "~/cmigemo-default-win64/dict/utf-8/migemo-dict"))
                ((eq system-type 'darwin) "/usr/local/Cellar/cmigemo/20110227/share/migemo/utf-8/migemo-dict")
              )))
  (setq migemo-user-dictionary nil)
  (setq migemo-regex-dictionaryel nil)
  (setq migemo-coding-system 'utf-8-unix))

(with-eval-after-load "js"
  (add-hook 'js-mode-hook 'js-indent)
  'js)

(defun js-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local js-indent-level 4))

(use-package json-mode
  :no-require t
  :ensure t
  :commands (json-mode)
  :mode (("\\.json$" . json-mode) (".babelrc" . json-mode) (".eslintrc" . json-mode))
  :defer t
  :config
  (add-hook 'json-mode-hook 'auto-revert-mode)
  (add-hook 'json-mode-hook 'hs-minor-mode)
  (add-hook 'json-mode-hook 'json-mode-config)
)

(use-package json
  :commands (json-pretty-print-buffer)
  :defer t
)

(defun json-validate ()
  (let ((buffer (current-buffer)))
    (save-excursion
      (with-temp-buffer
        (erase-buffer)
        (insert-buffer-substring buffer)
        (json-pretty-print-buffer)
        nil))))

(defun json-mode-config ()
  (setq-local indent-tabs-mode nil)
  (setq-local js-indent-level 2)
  ;; local-hook
  (add-hook 'write-contents-functions 'json-validate nil t)
  )

(defalias '** 'expt)

(use-package markdown-mode
  :no-require t
  :ensure t
  :after (exec-path-from-shell)
  :when (eval-when-compile (executable-find "markdown"))
  :defer t
  :mode (("\\.md$" . markdown-mode))
  :config
  (setq markdown-command "markdown")
  (setq markdown-open-command "markdown")
)

(use-package js2-mode
  :ensure t
  :mode (("\\.es6$" . js2-mode) ("\\.js$" . js2-mode))
  :defer t
  :config
  (progn
    ;; setting per project (.dir-local.el)
    (setq js2-strict-trailing-comma-warning nil)
    (setq js2-strict-inconsistent-return-warning nil))
  (setq js2-global-externs '("describe" "context" "it" "require" "exports" "module" "process" "after" "before" "afterEach" "beforeEach"))
  (add-hook 'js2-mode-hook 'js2-indent)
  (add-hook 'js2-mode-hook 'which-function-mode)
  (add-hook 'js2-mode-hook 'highlight-symbol-mode)
  )

(defun js2-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local js2-basic-offset 4)
  (setq-local tab-width 4))

(with-eval-after-load "eshell"
  (when (require 'ansi-color nil t)
    (add-hook 'eshell-load-hook 'ansi-color-for-comint-mode-on)
    (defun eshell-handle-ansi-color ()
      (ansi-color-apply-on-region eshell-last-output-start
                                  eshell-last-output-end))
  (add-to-list 'eshell-output-filter-functions 'eshell-handle-ansi-color)))

(defun rust-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local rust-indent-offset 4)
  (setq-local rust-indent-method-chain nil)
  (setq-local rust-indent-where-clause t)
  )

(use-package rust-mode
  :no-require t
  :ensure t
  :after (exec-path-from-shell)
  :if (eval-when-compile (executable-find "rustc"))
  :mode (("\\.rs$" . rust-mode) ("\\.rlib$" . rust-mode))
  :defer t
  :init
  (add-hook 'rust-mode-hook 'rust-indent)
  (add-hook 'rust-mode-hook 'which-function-mode)
  (add-hook 'rust-mode-hook 'highlight-symbol-mode)
  )

(defun git-config-indent ()
  (setq-local indent-tabs-mode t)
  (setq-local tab-width 4))

(use-package git-config-mode
  :no-require t
  :mode (("\\.gitconfig$" . git-config-mode))
  :defer t
  :config
  (add-hook 'git-config-mode-hook 'git-config-indent))


(use-package css-mode
  :no-require t
  :commands (css-mode)
  :defer t
  :mode (("\\.css$" . css-mode))
  :init
  (add-hook 'css-mode-hook 'css-mode-indent))

(defun css-mode-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local css-indent-offset 4))

(defun yaml-mode-indent ()
  (setq-local indent-tabs-mode nil)
  (setq-local tab-width 2))

(use-package yaml-mode
  :no-require t
  :ensure t
  :commands (yaml-mode)
  :mode (("\\.ya?ml" . yaml-mode))
  :defer t
  :init
  (add-hook 'yaml-mode-hook 'yaml-mode-indent)
  :config
)

(use-package undo-tree
  :no-require t
  :ensure t
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'global-undo-tree-mode)
  :config
  (define-key global-map (kbd "C-/") 'undo-tree-redo)
)

(use-package anzu
  :requires (migemo)
  :no-require t
  :ensure t
  :defer t
  :init
  (add-hook 'emacs-startup-hook 'global-anzu-mode)
  :config
  (setq anzu-use-migemo t)
  (setq anzu-mode-lighter "")
  (setq anzu-deactivate-region t)
  (setq anzu-search-threshold 1000)
  )

(use-package uniquify
  :no-require t
  :defer t
  :init (run-at-time 1.0 nil 'require 'uniquify)
  :config
  (setq uniquify-buffer-name-style 'post-forward-angle-brackets)
  )

;; like vim's '<,'>!
(when (eval-when-compile (executable-find "perl"))
  (defadvice shell-command-on-region (before shell-command-on-region-like-vim activate)
    (let* ((command-format "{ cat; echo; } | %s | perl -pe 'chomp if eof'")
           (new-command (format command-format (ad-get-arg 2))))
      (ad-set-arg 2 new-command))))

;; repository
(defvar gist-repository "git@gist.github.com:3b8519a505d479e97c1d6dfc0926d07d.git")

(when (eval-when-compile (eq window-system 'ns))
  (add-hook 'focus-in-hook 'ns-input-source-us)
  (add-hook 'after-init-hook 'ns-input-source-us)

  (defun ns-input-source-us ()
    (interactive)
    (do-applescript
     "tell application \"System Events\" to key code 102")))

(when (eval-when-compile (eq window-system 'ns))
  (setq ns-command-modifier 'meta))

(with-eval-after-load "battery"
  (add-hook 'emacs-startup-hook 'display-battery-mode))

(with-eval-after-load "repeat"
  (define-key global-map (kbd "C-x C-z") 'repeat))


(use-package thingopt
  :no-require t
  :ensure t :pin melpa
  :commands (define-thing-commands)
  :init (add-hook 'emacs-startup-hook 'define-thing-commands)
  :config
  (defvar mark-thing-map (make-sparse-keymap))
  (define-key global-map (kbd "M-@") mark-thing-map)
  (define-key mark-thing-map (kbd "@") 'mark-email)
  (define-key mark-thing-map (kbd "w") 'mark-word*)
  (define-key mark-thing-map (kbd "$") 'mark-line)
  (define-key mark-thing-map (kbd "/") 'mark-url)
  (define-key mark-thing-map (kbd ".") 'mark-sentence)
  (define-key mark-thing-map (kbd ")") 'mark-list)
  (define-key mark-thing-map (kbd "e") 'mark-sexp*)
  (define-key mark-thing-map (kbd "\"") 'mark-string))

(use-package ssh-config-mode
  :no-require t
  :ensure t :pin melpa
  :defer t
  )

(use-package dockerfile-mode
  :no-require t
  :ensure t :pin melpa
  :defer t
  )

(use-package haskell-mode
  :no-require t
  :ensure t :pin melpa
  :defer t
)

;; custom
(setq custom-file (locate-user-emacs-file "custom.el"))
(run-at-time 0.75 nil 'load custom-file 'noerr)

;; user specific
(run-at-time 1.0 nil 'load (locate-user-emacs-file "user") 'noerr)

(define-key global-map (kbd "C-z") nil)
(define-key global-map (kbd "C-x C-z") nil)

;; Local Variables:
;; coding: utf-8-unix
;; End: