init.el

;;; init.el --- init file if Emacs
;;; Commentary:
;;; Code:

(setq debug-on-error t)

;;; Misc
(setq-default bidi-display-reordering nil)
(setq inhibit-splash-screen t)
(setq history-delete-duplicates t)
(setq set-mark-command-repeat-pop t)

(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward-angle-brackets)
(setq uniquify-ignore-buffers-re "[^*]+")

(require 'saveplace)
(setq-default save-place t)
(setq save-place-file (concat user-emacs-directory "places"))

(show-paren-mode 1)

(setq-default indent-tabs-mode nil)

(global-hl-line-mode 1)

(savehist-mode 1)

(global-set-key (kbd "C-h") 'delete-backward-char)
(global-set-key [C-M-tab] 'clang-format-region)
(global-set-key (kbd "<hiragana-katakana>") 'toggle-input-method)
(global-auto-revert-mode 1)
(line-number-mode 1)
(column-number-mode 1)
(setq gc-cons-threshold (* 10 gc-cons-threshold))
(defalias 'yes-or-no-p 'y-or-n-p)

;;; Font
(set-face-attribute 'default nil :family "Camingo Code" :height 120)
(set-fontset-font t 'japanese-jisx0208 (font-spec :family "IPA Gothic" :height 120))

;;; Frame
(when window-system
  (setq default-frame-alist
        (append
         '((width . 116) (height . 41) (alpha . 80))
         default-frame-alist)))

(defun set-alpha (alpha-num)
  "Set frame parameter alpha by ALPHA-NUM."
  (interactive "nAlpha: ")
  (set-frame-parameter nil 'alpha (cons alpha-num '(80))))

;;; No backup
(setq make-backup-files nil)

;;; Pair
(electric-pair-mode t)

;;; Elpa
(require 'package)

;;; Standard package repositories
(let* ((no-ssl (and (memq system-type '(windows-nt ms-dos))
                    (not (gnutls-available-p))))
       (proto (if no-ssl "http" "https")))
  (add-to-list 'package-archives (cons "melpa" (concat proto "://melpa.org/packages/")) t)
  ;; Official MELPA Mirror, in case necessary.
  ;;(add-to-list 'package-archives (cons "melpa-mirror" (concat proto "://www.mirrorservice.org/sites/melpa.org/packages/")) t)
  (if (< emacs-major-version 24)
      ;; For important compatibility libraries like cl-lib
      (add-to-list 'package-archives '("gnu" . (concat proto "://elpa.gnu.org/packages/")))
    (unless no-ssl
      ;; Force SSL for GNU ELPA
      (setcdr (assoc "gnu" package-archives) "https://elpa.gnu.org/packages/"))))


(require 'cl-lib)

(defun require-package (package &optional min-version no-refresh)
  "Install given PACKAGE, optionally requiring MIN-VERSION.
If NO-REFRESH is non-nil, the available package lists will not be
re-downloaded in order to locate PACKAGE."
  (or (package-installed-p package min-version)
      (let* ((known (cdr (assoc package package-archive-contents)))
             (versions (mapcar #'package-desc-version known)))
        (if (cl-find-if (lambda (v) (version-list-<= min-version v)) versions)
            (package-install package)
          (if no-refresh
              (error "No version of %s >= %S is available" package min-version)
            (package-refresh-contents)
            (require-package package min-version t))))))

(defun maybe-require-package (package &optional min-version no-refresh)
  "Try to install PACKAGE, and return non-nil if successful.
In the event of failure, return nil and print a warning message.
Optionally require MIN-VERSION.  If NO-REFRESH is non-nil, the
available package lists will not be re-downloaded in order to
locate PACKAGE."
  (condition-case err
      (require-package package min-version no-refresh)
    (error
     (message "Couldn't install optional package `%s': %S" package err)
     nil)))

;;; Fire up package.el
(setq package-enable-at-startup nil)
(package-initialize)

(maybe-require-package 'recentf-ext)
(maybe-require-package 'ox-reveal)

;;; gfm
(when (maybe-require-package 'markdown-mode)
  (with-eval-after-load 'markdown-mode
    (add-to-list 'auto-mode-alist '("README\\.md\\'" . gfm-mode))))

;;; flycheck
(when (maybe-require-package 'flycheck)
  (add-hook 'after-init-hook #'global-flycheck-mode)
  (with-eval-after-load 'flycheck
    (when (maybe-require-package 'pos-tip)
      (with-eval-after-load 'pos-tip
        (flycheck-pos-tip-mode)))
    (custom-set-variables
     '(flycheck-display-errors-delay 0.0))
  (define-key flycheck-mode-map (kbd "C-c h") 'helm-flycheck)
  (define-key flycheck-mode-map (kbd "M-n") 'flycheck-next-error)
  (define-key flycheck-mode-map (kbd "M-p") 'flycheck-previous-error)))

;;; Rust
(let ((ld-lib-path (ignore-errors (car (process-lines "rustc" "--print" "sysroot")))))
  (when (and ld-lib-path (file-directory-p ld-lib-path))
    (setenv "LD_LIBRARY_PATH" (expand-file-name "lib" ld-lib-path))))

(when (maybe-require-package 'rust-mode)
  (defun my-rust-mode-hook nil
    "Configure rust mode."
    (progn
      (custom-set-variables '(rust-indent-method-chain t))
      (custom-set-variables '(rust-format-on-save t))
      (racer-mode)))
  (add-hook 'rust-mode-hook #'my-rust-mode-hook)
  (when (maybe-require-package 'racer)
    (defun my-racer-mode-hook nil
      "Configure racer mode."
      (progn
        (eldoc-mode)
        (company-mode)
        (define-key racer-mode-map (kbd "C-.") #'racer-describe)))
    (add-hook 'racer-mode-hook #'my-racer-mode-hook))
  (when (maybe-require-package 'flycheck-rust)
    (add-hook 'flycheck-mode-hook #'flycheck-rust-setup)))

;;; Elm

(when (and (maybe-require-package 'elm-mode) (maybe-require-package 'flycheck-elm))
  (add-hook 'flycheck-mode-hook #'flycheck-elm-setup))

;;; C / C++
(when (and (maybe-require-package 'google-c-style) (maybe-require-package 'irony))
  (defun my-c++-mode-hook nil
    "Configure c++ mode."
    (progn
      (google-set-c-style)
      (google-make-newline-indent)
      (setq-default flycheck-gcc-language-standard "c++11")
      (setq-default flycheck-clang-language-standard "c++11")
      (irony-mode)
      (company-mode)))
  (defun my-c-mode-hook nil
    "Configure c mode."
    (progn
      (google-set-c-style)
      (google-make-newline-indent))) 
  (add-hook 'c-mode-hook #'my-c-mode-hook)
  (add-hook 'c++-mode-hook #'my-c++-mode-hook)
  (setq-default irony-lang-compile-option-alist
                (quote ((c++-mode . "c++ -std=c++11 -lstdc++")
                        (c-mode . "c")
                        (objc-mode . "objective-c"))))
  (defun ad-irony--lang-compile-option nil
    "Company compile options."
    (defvar irony-lang-compile-option-alist)
    (let ((it (cdr-safe (assq major-mode irony-lang-compile-option-alist))))
      (when it (append '("-x") (split-string it "\s")))))
  (advice-add 'irony--lang-compile-option :override #'ad-irony--lang-compile-option)
  (add-hook 'irnony-mode-hook 'irony-cdb-autosetup-compile-options))

;;; helm
(when (maybe-require-package 'helm)
  (global-set-key (kbd "C-x b") 'helm-mini)
  (global-set-key (kbd "C-x C-f") 'helm-find-files)
  (global-set-key (kbd "C-x C-b") 'helm-buffers-list)
  (global-set-key (kbd "M-x") 'helm-M-x)
  (global-set-key (kbd "M-s o") 'helm-swoop)
  (global-set-key (kbd "M-y") 'helm-show-kill-ring)
  (setq-default dired-bind-jump nil)
  (when (maybe-require-package 'helm-ag)
    (global-set-key (kbd "C-M-g") 'helm-do-ag)
    (global-set-key (kbd "C-M-k") 'backward-kill-sexp))
  (require 'helm-config))

;;; all-ext
(maybe-require-package 'all-ext)

;;; Migemo
(when (maybe-require-package 'migemo)
  (setq-default migemo-command "cmigemo")
  (setq-default migemo-options '("-q" "--emacs"))
  ;; Set your installed path
  (setq-default migemo-dictionary "/usr/share/migemo/utf-8/migemo-dict")
  (setq-default migemo-user-dictionary nil)
  (setq-default migemo-regex-dictionary nil)
  (setq-default migemo-coding-system 'utf-8-unix)
  (with-eval-after-load 'migemo
    (helm-migemo-mode t)
    (migemo-init)))

;;; SKK
(when (maybe-require-package 'ddskk)
  (global-set-key (kbd "C-x j") 'skk-auto-fill-mode)
  (global-set-key (kbd "C-x C-j") 'skk-mode)
  (setq-default skk-show-candidates-nth-henkan-char 3)
  (setq-default skk-henkan-number-to-display-candidates 8)
  (setq-default skk-auto-insert-paren t)
  (setq-default skk-show-tooltip t)
  (setq-default skk-tooltip-parameters
        '((background-color . "dark blue")
          (border-color     . "alice blue")
          (foreground-color . "gray")
          (internal-border-width . 2)))
  (setq-default skk-use-search-web t)
  (defun my-skk-mode-hook nil
    "Configure skk mode."
    (if (eq major-mode 'yatex-mode)
        (progn
          (define-key skk-j-mode-map "\\" 'self-insert-command)
          (define-key skk-j-mode-map "$" 'YaTeX-insert-dollar))))
  (with-eval-after-load 'ddskk
    (add-hook 'skk-mode-hook 'my-skk-mode-hook)))


;;; YaTeX configuration option
(when (maybe-require-package 'yatex)
  (setq auto-mode-alist (cons '("\\.tex$" . yatex-mode) auto-mode-alist))
  (setq-default YaTeX-latex-message-code 'utf-8)
  (setq-default YaTeX-use-LaTeX2e t)
  ;; (setq tex-command "latexmk -lualatex")
  ;; (setq tex-command "latexmk -gg -pdf")
  (setq-default tex-command "latexmk -pdf -shell-escape")
  (setq-default dvi2-command "evince"))

;;; White space
(autoload 'whitespace-mode "whitespace" "Toggle whitespace visualization." nil t)

;;; company-mode
;; color
(when (maybe-require-package 'color)
  (with-eval-after-load 'color
    (let ((bg (face-attribute 'default :background)))
      (custom-set-faces
       `(company-tooltip ((t (:inherit default :background ,(color-lighten-name bg 2)))))
       `(company-scrollbar-bg ((t (:background ,(color-lighten-name bg 10)))))
       `(company-scrollbar-fg ((t (:background ,(color-lighten-name bg 5)))))
       `(company-tooltip-selection ((t (:inherit font-lock-function-name-face))))
       `(company-tooltip-common ((t (:inherit font-lock-constant-face))))))))

;; keymap and etc
(when (maybe-require-package 'company)
  (setq-default company-idle-delay 0)
  (setq-default company-minimum-prefix-length 2)
  (setq-default company-selection-wrap-around t)
  (with-eval-after-load 'company
    (define-key company-active-map (kbd "M-n") nil)
    (define-key company-active-map (kbd "M-p") nil)
    (define-key company-active-map (kbd "C-n") #'company-select-next)
    (define-key company-active-map (kbd "C-p") #'company-select-previous)
    (add-to-list 'company-backends 'company-irony)
    (add-to-list 'company-backends 'company-jedi)))

;;; python
(setq-default flycheck-python-flake8-executable "python3")

(when (maybe-require-package 'jedi-core)
  (setq-default jedi:complete-on-dot t)
  (setq-default jedi:use-shortcuts t)
  (setq-default jedi:use-shortcuts t)
  (add-hook 'python-mode-hook 'jedi:setup)
  (add-hook 'python-mode-hook 'company-mode))

;;; undo-tree
;;; note: C-/ undo-tree-undo
;;;       C-x u undo-tree-visualize
(when (maybe-require-package 'undo-tree)
  (global-undo-tree-mode 1)
  (global-set-key (kbd "C-\\") 'undo-tree-redo))

;;; magit
(when (maybe-require-package 'magit)
  (setq-default magit-diff-refine-hunk t)
  (global-set-key (kbd "C-x g") 'magit-status)
  (global-set-key (kbd "C-x M-g") 'magit-dispatch))


(defun enable-pretty-entities (is_enable_str)
  "If IS_ENABLE_STR is y then enable assign t to org-pretty-entities."
  (interactive "senable pretty entities(y/n):")
  (custom-set-variables '(org-pretty-entities
                          (pcase is_enable_str
                            ((or "y" "Y") t)
                            (s nil)))))

;;; Custom
(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(custom-enabled-themes (quote (misterioso)))
 '(flycheck-display-errors-delay 0.0)
 '(helm-ag-base-command "rg --no-heading")
 '(helm-ag-ignore-buffer-patterns (quote ("\\.txt\\'" "\\.mkd\\'")))
 '(helm-ag-insert-at-point (quote symbol))
 '(helm-follow-mode-persistent t)
 '(magit-branch-arguments nil)
 '(package-selected-packages
   (quote
    (flycheck-elm vue-mode rjsx-mode company-jedi elixir-mode dash yaml-mode magit toml-mode clang-format helm-flycheck helm-firefox helm-swoop helm-google htmlize ox-reveal web-mode markdown-edit-indirect flycheck-haskell lua-mode recentf-ext helm-ag graphviz-dot-mode fish-mode all-ext yatex flycheck-pos-tip package-utils company-irony irony undo-tree ess company racer flycheck-rust flycheck rust-mode ddskk)))
 '(racer-find-definition-other-window t)
 '(rust-format-on-save nil)
 '(rust-indent-method-chain t))

(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(company-scrollbar-bg ((t (:background "#415061"))))
 '(company-scrollbar-fg ((t (:background "#374352"))))
 '(company-tooltip ((t (:inherit default :background "#313c49"))))
 '(company-tooltip-common ((t (:inherit font-lock-constant-face))))
 '(company-tooltip-selection ((t (:inherit font-lock-function-name-face)))))

(provide 'init)
;;; init.el ends here