mitchty
/
dotfiles
1
0
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
67 İşleme
2 Dallar
1.1 MiB
 
 
 
 
Ağaç: 0550af12bb
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'0550af12bb'den
${ noResults }
dotfiles/emacs/.emacs.d/emacs.org

26 KiB
Ham Suçlama Geçmiş

Emacs Configuration

readme

This is my emacs configuration file. I don't encourage anyone to use this verbatim, but if you wanted to this is how you would do so:

Clone this repo 

git clone https://github.com/mitchty/dotfiles

Preferably backup your emacs configuration

Always good to back things up, just in case you hate how I did things. 

tar cvf ~/.emacs-backup.tar ~/.emacs.d ~/.emacs

Remove/move your old configuration

This is up to you to do right, just an example. 

rm -fr ~/.emacs.d ~/.emacs

Lastly copy necessary files 

mkdir ~/.emacs.d
cp dotfiles/init.el dotfiles/emacs.org ~/.emacs.d

prelude

Startup related tasks/setup that might be used later on.

emacs package setup

Setup the builtin emacs package manager. 

  (require 'package)
  (package-initialize)

Add in the standard package archive urls. 

  (add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t)
  (add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
  (add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/") t)

use-package bootstrap

This configuration is using use-package extensively. Install it straight away. 

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

  (require 'use-package)

match end of string function 

  (defun string/ends-with (string suffix)
    "Return t if STRING ends with SUFFIX."
    (and (string-match (rx-to-string `(: ,suffix eos) t)
                       string)
         t)
    )

always babel tangle and byte compile emacs.org

Add a save hook to always tangle and byte compile emacs.org file when we save it. 

  (defun tangle-init ()
    "If the current buffer is 'emacs.org' the code-blocks are
  tangled, and the tangled file is compiled."
    (when (string/ends-with (buffer-file-name)  ".emacs.d/emacs.org")
      (let ((prog-mode-hook nil))
        (org-babel-tangle)
        (byte-compile-file (concat user-emacs-directory "emacs.el")))
      )
    )

  (add-hook 'after-save-hook 'tangle-init)

debug on error

Not having to start emacs with –debug-init is useful. 

  (setq debug-on-error t)

emacs server

Start up the emacs server if it isn't running. 

  (load "server")
  (unless (server-running-p) (server-start))

theme

Solarized light is decent. I'll just use that. Note, to prevent flicker this is setup early in startup. 

  (use-package solarized-theme :ensure t :init (load-theme 'solarized-light 't))

os detection

Make it easier to determine what os we're running on. 

  (defvar on-mswindows (string-match "windows" (symbol-name system-type))
    "Am I running under windows?")
  (defvar on-osx (string-match "darwin" (symbol-name system-type))
    "Am I running under osx?")
  (defvar on-linux (string-match "gnu/linux" (symbol-name system-type))
    "Am I running under linux?")

disable pointless startup stuff

Like the startup screen and the echo hooey. 

  (custom-set-variables
   '(inhibit-startup-screen t)
   '(inhibit-startup-message t)
   '(inhibit-startup-echo-area-message t)
   )

temporary files

Keep temporary stuff isolated from everyone else. It infects everything otherwise. As bad as the .DS_Store files on osx. 

  (custom-set-variables
   '(temporary-file-directory "/tmp")
   '(backup-directory-alist `((".*" . ,temporary-file-directory)))
   '(auto-save-file-name-transforms `((".*" ,temporary-file-directory t)))
   '(create-lockfiles nil)
   '(make-backup-files nil)
   '(auto-save-default nil)
   '(backup-by-copying t)
   '(auto-save-list-file-prefix temporary-file-directory)
   '(backup-directory-alist `((".*" . ,temporary-file-directory)))
   '(auto-save-file-name-transforms `((".*" ,temporary-file-directory t)))
   )

auto revert

Update files in open buffers as they're changed on disk, freaking annoying without this on. 

  (custom-set-variables '(global-auto-revert-mode t))

dired

Use dired-x. 

  (add-hook 'dired-load-hook (function (lambda () (load "dired-x"))))

ediff

For those rare times I use it, make it a bit less derp on output. 

  (setq ediff-window-setup-function 'ediff-setup-windows-plain)
  (setq ediff-split-window-function 'split-window-horizontally)

always remove trailing whitespace

Trailing whitespace is not normally useful. Remove it always on save in the before-save-hook. 

  (add-hook 'before-save-hook 'delete-trailing-whitespace)

chmod u+x on save for scripts

Because its derp to have to chmod 755 stuff after I save. Honestly, do it for me kthxbai. 

  (add-hook 'after-save-hook 'executable-make-buffer-file-executable-if-script-p)

misc text related

line wrap

Line wrapping is useful. Enable it globally for a start.

Need word-wrap so kill line kills the line, not the displayed line. 

  (global-visual-line-mode t)
  (custom-set-variables '(word-wrap t))

default major mode

So if we don't know, call it text-mode. 

  (custom-set-variables '(default-major-mode 'text-mode))

encoding

utf8 is the best. Default to it. 

  (custom-set-variables '(locale-coding-system 'utf-8))
  (set-terminal-coding-system 'utf-8)
  (set-keyboard-coding-system 'utf-8)
  (set-selection-coding-system 'utf-8)
  (prefer-coding-system 'utf-8)

text selection

If I selected text, delete the selection, I probably meant it emacs. 

  (delete-selection-mode 1)

line width

80 char line columns not 72. 

  (custom-set-variables '(fill-column 80))

we aren't banging rocks anymore

Double spacing after a line isn't needed. We aren't animals emacs, we have computers. 

  (set-default 'sentence-end-double-space nil)

sentence end

Semi related to the above, make the sentence endings a bit more code-ish. 

  (custom-set-variables
   '(sentence-end "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*")
   '(sentence-end-double-space nil)
   )

default tab-width

Two seems sensible, cause well, tabs are evil incarnate.

Lets use a tab width of 2 by default. 

  (custom-set-variables '(default-tab-width 2))

whitespace

Customize whitespace mode to make tabs obvious as boxes, and to highlight lines over 80 characters in length. 

(require 'whitespace)

(setq whitespace-style '(face tabs trailing))

(set-face-attribute 'whitespace-tab nil
                    :foreground "#2075c7"
                    :background "lightgrey")

(set-face-attribute 'whitespace-line nil
                    :foreground "#2075c7"
                    :background "lightgrey")

uncategorized

I have no idea how to label these.

Highlight parens. 

  (show-paren-mode)

Typing out yes or no is stupid. 

  (defalias 'yes-or-no-p 'y-or-n-p)

global key bindings

Global key bindings. 

  (global-set-key (kbd "C-,") 'kill-whole-line)
  (global-set-key (kbd "C-x C-m") 'compile)

x copy/paste 

  (when (and on-linux (window-system))
    (progn
      (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)
      (setq x-select-enable-clipboard t)
      )
    )

appearance

modeline

Update the time every ~3 seconds in the mode line. 

  (custom-set-variables
   '(display-time-default-load-average nil)
   '(display-time-format "%T")
   '(display-time-interval 3)
   )
  (display-time-mode)

Display line and column always in the modeline. 

  (custom-set-variables
   '(line-number-mode t)
   '(column-number-mode t)
   )

Format the mode line, I… can't decipher this anymore nor do I care to, it works eff it. 

  (custom-set-variables
   '(mode-line-format
     (list
      '(:eval (propertize "%b " 'face 'font-lock-keyword-face
                          'help-echo (buffer-file-name)))
      (propertize "%l" 'face 'font-lock-type-face) ","
      (propertize "%c" 'face 'font-lock-type-face) " ["
      '(:eval (propertize "%m" 'face 'font-lock-preprocessor-face
                          'help-echo mode-line-modes)) "]["
      '(:eval (propertize
               (if overwrite-mode "Ovr" "I")
               'face 'font-lock-preprocessor-face
               'help-echo (concat "Buffer is in "
                                  (if overwrite-mode "overwrite" "insert") " mode")))
      '(:eval (when (buffer-modified-p)
                (concat ","  (propertize "M"
                                         'face 'font-lock-warning-face
                                         'help-echo "Buffer has been modified"))))
      '(:eval (when buffer-read-only
                (concat ","  (propertize "RO"
                                         'face 'font-lock-type-face
                                         'help-echo "Buffer is read-only")))) "] "
      '(:eval (when window-system
                (propertize
                 (format-time-string "%H:%M:%S")
                 'help-echo
                 (concat (format-time-string "%c; ")
                         (emacs-uptime "Uptime:%hh")))))
      )
     )
   )

gui

When i'm running in a terminal emacs, most of this junk isn't needed. For that matter gui counts for most.

Basically, never show the tool bar or the scroll bar in gui or tty. In gui its ok to show the menu-bar. 

  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (when (not window-system)
    (menu-bar-mode -1))

fonts

List of fonts in order of preference. 

  (defvar my/gui-fonts
    '(
      "PragmataPro"
      "Pragmata Pro" ;; Seems to register differently on osx than X
      "Source Code Pro"
      "Menlo"
      "Monaco"
      )
    )

Set preferred font list when we're in a gui emacs session. 

  (when window-system
    (if (find-font  (font-spec :name (car my/gui-fonts)))
        (progn (set-frame-font (car my/gui-fonts))
               (set-face-attribute 'default nil :height 180))
      (progn (set-gui-font (cdr my/gui-fonts))))
    )

tty

Enable mouse mode for the console and use the mousewheel if possible. 

  (unless window-system
    (require 'mouse)
    (xterm-mouse-mode t)
    (global-set-key [mouse-4] '(lambda ()
                                 (interactive)
                                 (scroll-down 1)))
    (global-set-key [mouse-5] '(lambda ()
                                 (interactive)
                                 (scroll-up 1)))
    (defun track-mouse (e))
    )

packages

All the packages I use.

tramp 

  (use-package tramp :ensure t)

exec-path-from-shell

Turns out that someone wrote this exact thing already. Yay get to drop my own crap. 

  (use-package exec-path-from-shell
    :ensure t
    :init (if on-osx (exec-path-from-shell-initialize))
    )

expand-region 

  (use-package expand-region :ensure t :bind ("C-]" . er/expand-region))

helm

By Helms Deep use Helm to do ALL THE THINGS. IDO is ass in comparison. 

  (use-package helm
    :ensure t
    :diminish helm-mode
    :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-x c o" . helm-occur))
    :init (progn
            (require 'helm-config)
            (helm-mode 1)
            (use-package helm-descbinds
              :ensure t
              :bind (("C-h b" . helm-descbinds)
                     ("C-h w" . helm-descbinds))
              )
            (use-package helm-ag :ensure t)
            (use-package helm-projectile :ensure t)
            )
    )

magit

Make git not ass to use. At least in emacs. magit is the best git interface… in the world. 

  (use-package magit
    :ensure t
    :commands (magit-init
               magit-status
               magit-diff
               magit-commit)
    :bind ("C-x m" . magit-status)
    :config
    (progn
      (defadvice magit-status (around magit-fullscreen activate)
        (window-configuration-to-register :magit-fullscreen)
        ad-do-it
        (delete-other-windows))

      (defadvice magit-quit-window (around magit-restore-screen activate)
        ad-do-it
        (jump-to-register :magit-fullscreen)))
    )

  (use-package magit-blame
    :ensure magit
    :ensure t
    :commands (magit-blame-mode)
    )

workgroups2

Save workgroup layouts. Similar..ish to desktop-save. 

  (use-package workgroups2
    :ensure t
    :init (progn
            ;; Can't use :bind OR :config for this sadly
            ;; also annoying, is that I have to set this before
            ;; running workgroups-mode. Hokey stuff.
            ;;
            ;; Also note, use setq here not custom-set-variables
            ;; workgroups2 can't detect stuff thats customized.
            (custom-set-variables
             '(wg-session-file  "~/.emacs.d/workgroups")
             '(wg-prefix-key (kbd "C-c C-w"))
             )
            (workgroups-mode 1)
            )
    )

autopair

Highlight matching ()'s []'s etc… 

  (use-package autopair
    :ensure t
    :config
    (progn (custom-set-variables '(autopair-blink 'nil)))
    )

org-mode

Org-mode keybindings and settings, pretty sparse really. 

  (use-package org
               :ensure org-plus-contrib
               :bind (("C-c a" . org-agenda)
                      ("C-c b" . org-iswitchb)
                      ("C-c c" . org-capture)
                      ("C-c l" . org-store-link)
                      ("C-c p" . org-latex-export-to-pdf))
               :config
               (progn
                 (custom-set-variables
                  '(org-log-done t)
                  '(org-hide-leading-stars t)
                  )
                 )
               )

flycheck

Flycheck for on the fly checking of code. 

  (use-package flycheck
    :ensure t
    :init
    (custom-set-variables '(flycheck-indication-mode 'left-fringe))
    :config
    (add-hook 'prog-mode-hook 'flycheck-mode)
    )

Need to vet this, used it more when I did more c. But its handy for non standard pkg-config setups.

Not tangled into the config intentionally. 

  (defun pkg-config-add-lib-cflags (pkg-config-lib)
    "This function will add necessary header file path of a
  specified by `pkg-config-lib' to `flycheck-clang-include-path', which make it
  completionable by auto-complete-clang"
    (interactive "spkg-config lib: ")
    (if (executable-find "pkg-config")
        (if (= (shell-command
                (format "pkg-config %s" pkg-config-lib))
               0)
            (setq flycheck-clang-include-path
                  (append flycheck-clang-include-path
                          (split-string
                           (shell-command-to-string
                            (format "pkg-config --cflags-only-I %s"
                                    pkg-config-lib)))))
          (message "Error, pkg-config lib %s not found." pkg-config-lib))
      (message "Error: pkg-config tool not found.")))

auto-complete

Auto complete functionality is nice to have. 

    (use-package auto-complete
        :ensure t
        :init (progn (require 'auto-complete-config)
                     (ac-config-default)
                     (global-auto-complete-mode t)
        ))

smartparens

Helpfully inserts matching parens, can be a pita too. 

  (use-package smartparens
    :ensure t
    :init (progn (add-hook 'prog-mode-hook (smartparens-mode)))
    )

rainbow delimiters

Makes matching parens easier. 

  (use-package rainbow-delimiters
    :ensure t
    :config
    (progn (add-hook 'prog-mode-hook (rainbow-delimiters-mode)))
    )

uniquify

Make buffer names unique based on their directory and not have <N> or other nonsense. 

  (require 'uniquify)
  (custom-set-variables '(uniquify-buffer-name-style 'post-forward))

desktop-save

Desktop saving of session information handy to keep the same buffers between sessions. 

  (require 'desktop)

  (desktop-save-mode 1)

  (custom-set-variables
   '(desktop-restore-eager 5)
   '(desktop-path '("~/.emacs.d"))
   '(desktop-dirname  "~/.emacs.d")
   '(desktop-base-file-name "desktop")
   )

  (defun local-desktop-save ()
    (interactive)
    (if (eq (desktop-owner) (emacs-pid))
        (desktop-save desktop-dirname)))

  (add-hook 'auto-save-hook 'desktop-save-in-desktop-dir)

fic-mode

Highlight TODO/FIXME type messages in comments. 

  (use-package fic-mode
    :ensure t
    :config
    (progn (add-hook 'prog-mode-hook (turn-on-fic-mode)))
    )

projectile 

  (use-package projectile
    :ensure t
    :idle (projectile-global-mode)
    :config
    (progn (require 'helm-projectile)
           (helm-projectile-on))
    )

git gutter 

  (use-package git-gutter
    :ensure t
    :config
    (progn (global-git-gutter-mode t))
    )

clang-format 

  (use-package clang-format
    :ensure t
    :bind (([C-M-tab] . clang-format-region))
    )

ggtags 

  (use-package ggtags :ensure t)

company-mode

Completion tips. 

  (use-package company-mode
    :ensure t
    :config
    (progn (add-hook 'after-init-hook 'global-company-mode))
    )

yaml-mode

For.. yaml 

  (use-package yaml-mode :ensure t)

writegood-mode

So I write gooder. Me fail English? Thats unpossible. 

  (use-package writegood-mode :ensure t)

restclient

Comes in handily for those times you need it. 

  (use-package restclient :ensure t)

helm-gtags 

  (use-package helm-gtags :ensure t)

jedi

Make python coding like an ide. 

  (use-package jedi
    :ensure t
    :init
    (progn (add-hook 'python-mode-hook 'jedi:setup))
    :config
    (progn (custom-set-variables '(jedi:complete-on-dot t)))
    )

company-anaconda

Make it even easier with hints like intellisense. 

  (use-package company-anaconda
    :ensure t
    :config
    (progn
      (add-to-list 'company-backends 'company-anaconda)
      (add-hook 'python-mode-hook 'anaconda-mode)
      )
    )

haskell-mode

Need to make haskell source be all pretty. 

  (use-package haskell-mode
    :ensure t
    :config
    (progn
      (use-package hindent
        :ensure t
        :config
        (progn
          (add-hook 'haskell-mode-hook #'hindent-mode)
          )
        )
      (use-package flycheck-haskell :ensure t)
      (use-package flycheck-hdevtools
        :ensure t
        :config
        (progn
          (add-hook 'haskell-mode-hook 'flycheck-mode)
          )
        )
      (use-package ghc
        :ensure t
        :config
        (progn
          (autoload 'ghc-init "ghc" nil t)
          (autoload 'ghc-debug "ghc" nil t)
          (add-hook 'haskell-mode-hook (lambda ()
                                         (ghc-init)
                                         )
                    )
          )
        )
      (add-hook 'haskell-mode-hook 'interactive-haskell-mode)
      (add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
      (add-hook 'haskell-mode-hook 'turn-on-haskell-simple-indent)
      (custom-set-variables
       '(haskell-program-name "ghci")
       '(haskell-font-lock-symbols t)
       '(haskell-tags-on-save t)
       )
      (add-to-list 'completion-ignored-extensions ".hi")
      )
    )

mode related

common defaults

Common mode defaults I think are sensible.

prog-mode hook 
  (add-hook 'prog-mode-hook
        '(lambda ()
           (auto-complete-mode) ;; can't get this to work with use-package easily
           (interactive)
           (hl-line-mode)
           (whitespace-mode)
           (visual-line-mode)
           (custom-set-variables
            '(indent-tabs-mode nil)
            '(tab-width 2)
            )
          )
        )
c 
  (add-to-list 'auto-mode-alist '("\\.[chm]\\'" . c-mode))
  (add-hook 'c-mode-common-hook
            '(lambda ()
               (global-set-key "\C-x\C-m" 'compile)
               (setq flycheck-clang-language-standard "c11")
               (setq flycheck-idle-change-delay 2)
               (setq flycheck-highlighting-mode 'symbols)
  ;; later...
  ;;             (add-hook 'before-save-hook 'clang-format-buffer nil t)
               (c-toggle-auto-state 1)
               (setq-default c-basic-offset 2
                             tab-width 2
                             indent-tabs-mode nil
                             c-electric-flag t
                             indent-level 2
                             c-default-style "bsd"
                             backward-delete-function nil)
               ))
elisp

TODO: fixme 

(add-hook 'emacs-lisp-hook
          (lambda ()
            (define-key emacs-lisp-map
              "\C-x\C-e" 'pp-eval-last-sexp)
            (define-key emacs-lisp-map
              "\r" 'reindent-then-newline-and-indent)))
python 
  (add-hook 'python-mode-hook
            '(lambda ()
               (flycheck-select-checker 'python-flake8)
               (flycheck-select-checker 'python-pylint)
               )
            )
shell 
  (autoload 'sh--mode "sh-mode" "mode for shell stuff" t)

  (add-to-list 'auto-mode-alist '("\\.sh$\\'" . sh-mode))
  (add-to-list 'auto-mode-alist '("\\.[zk]sh$\\'" . sh-mode))
  (add-to-list 'auto-mode-alist '("\\.bash$\\'" . sh-mode))
  (add-to-list 'auto-mode-alist '("\\[.].*shrc$\\'" . sh-mode))
  (add-to-list 'auto-mode-alist '("sourceme$\\'" . sh-mode))

  (add-hook 'sh-mode-hook
            '(lambda ()
               (setq sh-basic-offset 2 sh-indentation 4
                     sh-indent-for-case-label 0 sh-indent-for-case-alt '+)))

auto-insert-mode new file templates

Use auto-insert-mode to insert in templates for blank files.

So first up, add auto-insert to find-file-hooks so we insert straight away. Also setup the copyright bit to minimally put in name. 

  (add-hook 'find-file-hooks 'auto-insert)
  (defvar auto-insert-copyright (user-full-name))

Create auto-insert-alist so all the mode lists are the same 

  (defvar auto-insert-alist '(()))
c 
    (setq auto-insert-alist
          (append
           '(
             ((c-mode . "c")
              nil
              "/*\n"
              "File: " (file-name-nondirectory buffer-file-name) "\n"
              "Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
              "Description: " _ "\n"
              "*/\n"
              "#include <stdio.h>\n"
              "#include <stdlib.h>\n\n"
              "int main(int argc, char **argv) {\n"
              "  return 0;\n"
              "}\n"
              )
             )
           auto-insert-alist)
          )
elisp 
    (setq auto-insert-alist
          (append
           '(
             ((emacs-lisp-mode . "elisp")
              nil
              ";;-*-mode: emacs-lisp; coding: utf-8;-*-\n"
              ";; File: " (file-name-nondirectory buffer-file-name) "\n"
              ";; Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
              ";; Description: " _ "\n"
              )
             )
           auto-insert-alist)
          )
python 
  (setq auto-insert-alist
        (append
         '(((python-mode . "python")
           nil
           "#!/usr/bin/env python\n"
           "# -*-mode: Python; coding: utf-8;-*-\n"
           "# File: " (file-name-nondirectory buffer-file-name) "\n"
           "# Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
           "# Description: " _ "\n\n"
           )
           )
         auto-insert-alist)
        )
shell 
  (setq auto-insert-alist
        (append
         '(
           ((sh-mode . "sh")
            nil
            "#!/usr/bin/env sh\n"
            "#-*-mode: Shell-script; coding: utf-8;-*-\n"
            "# File: " (file-name-nondirectory buffer-file-name) "\n"
            "# Copyright: " (substring (current-time-string) -4) " " auto-insert-copyright "\n"
            "# Description: " _ "\n"
            "export script=$(basename \"$0\")\n"
            "export dir=$(cd \"$(dirname \"$0\")\"; pwd)\n"
            "export iam=${dir}/${script}\n"
            )
           )
         auto-insert-alist)
        )

custom

Load this up last to allow for local customization if needed and to keep from custom writing to the init.el file. 

  (setq custom-file "~/.emacs.d/custom.el")
  (load custom-file 'noerror)