legacy-dotfiles/.emacs.d/init.org

#+TITLE: Emacs init
#+STYLE: <link href="http://ryuslash.ninth.su/test2.css" rel="stylesheet">
#+OPTIONS: author:nil

* Startup

  Startup requires a bit of customization to handle all my
  customizations.

** Load paths

   I have two versions of Emacs installed on my main computer.  I have
   a daily build of Emacs's ~trunk~ (or currently ~emacs-24~) branch from
   bazaar and I have the official ~emacs~ package from archlinux
   installed.  I keep that second one around so that the occasional
   emacs package that I install using ~pacman~ will recognize it as a
   dependency and so that if there has been some horrible mistake in
   the ~trunk~ branch I still have a stable version to fall back
   on[fn:1].

*** Package initialization

    In order for packages installed through ELPA to be included
    without having to mess with load paths and such, use:

    #+NAME: package-initialize
    #+BEGIN_SRC emacs-lisp
      (package-initialize)
    #+END_SRC

*** site-lisp

    Because of the setup I wrote about I need to have both the
    self-built ~site-lisp~ directory in my load path *and* the "official"
    one.

    #+NAME: load-site-lisps
    #+BEGIN_SRC emacs-lisp
      (mapc #'oni:add-all-to-load-path
            '("/usr/share/emacs/site-lisp"
              "/usr/local/emacs/share/emacs/site-lisp"))
    #+END_SRC

    The =oni:add-all-to-load-path= function just binds =default-directory=
    to the given directory and calls
    =normal-top-level-add-subdirs-to-load-path= to add it and all its
    subdirectories to the load path.

    #+NAME: add-all
    #+BEGIN_SRC emacs-lisp
      (defun oni:add-all-to-load-path (dir)
        (add-to-list 'load-path dir)
        (let ((default-directory dir))
          (normal-top-level-add-subdirs-to-load-path)))
    #+END_SRC

**** TODO Add load paths in different order depending on version

     The officially installed version should load
     =/usr/share/emacs/site-lisp= before
     =/usr/local/emacs/share/emacs/sit-lisp= and the bzr version should
     do the reversed.

*** Projects

    Then there are some projects I'm working on, which I use on a
    daily basis, these should also be added so I don't have to
    constantly remove and re-install them through ~package.el~ when
    working on them.  And there is the ~load-defs.el~ in my personal
    ~site-lisp~ directory of course.

    #+NAME: load-projects
    #+BEGIN_SRC emacs-lisp
      (mapc #'oni:add-to-load-path-maybe-load-defs
            '("~/projects/emacs/dispass.el" "~/var/src/emacs/mode-icons"
              "~/.emacs.d/site-lisp"))
    #+END_SRC

    The =oni:add-to-load-path-maybe-load-defs= function just adds the
    given directory to the load path and then looks for a file named
    ~loaddefs.el~ within that directory, if it exists it loads it.

    #+NAME: add-with-loaddefs
    #+BEGIN_SRC emacs-lisp
      (defun oni:add-to-load-path-maybe-load-defs (dir)
        (add-to-list 'load-path dir)
        (let ((loaddefs (concat dir "/loaddefs.el")))
          (when (file-exists-p loaddefs)
            (load loaddefs))))
    #+END_SRC

*** Themes

    And, finally, I'm also working on a color theme for emacs, this
    should be added to ~custom-theme-load-path~.  By using =mapc= here as
    well I'm keeping in mind that this isn't the first theme I've
    worked on and it might not be the last either.

    #+NAME: load-themes
    #+BEGIN_SRC emacs-lisp
      (mapc #'oni:add-to-custom-theme-load-path
            '("~/projects/emacs/yoshi-theme"))
    #+END_SRC

    The =oni:add-to-custom-theme-load-path= just adds the given
    directory to the cutom theme load path.

    #+NAME: add-themes
    #+BEGIN_SRC emacs-lisp
      (defun oni:add-to-custom-theme-load-path (dir)
        (add-to-list 'custom-theme-load-path dir))
    #+END_SRC

*** Evaluation

    Because during byte-compilation certain parts loaded so far might
    also be required I put it in an =eval-and-compile= form, so that all
    components are loaded with ~emacs -Q~ as well.  Without this
    compilation might fail at certain points.

    #+BEGIN_SRC emacs-lisp :tangle init2.el :noweb yes
      (eval-and-compile
        <<add-all>>

        <<add-with-loaddefs>>

        <<add-themes>>

        <<package-initialize>>
        <<load-site-lisps>>
        <<load-projects>>
        <<load-themes>>)
    #+END_SRC

** Modules

   While I try to use =eval-after-load= and =autoload= as much as
   possible, some things require direct =require='ing to be of use.

*** Require

    - ~auto-complete-config~ :: This sets up some default settings to
         make ~auto-complete~ work for most[fn:2] of the modes it
         supports.

   #+BEGIN_SRC emacs-lisp :tangle init2.el
     (require 'auto-complete-config)
   #+END_SRC

    - ~geiser-install~ :: Sets up geiser autoloads and such.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (require 'geiser-install)
    #+END_SRC

    - ~uniquify~ :: Provides more helpful buffer name uniquification.
                  The default of using ~buffer-name<2>~ is boring and
                  uninformative, ~uniquify~ fixes this.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (require 'uniquify)
    #+END_SRC

    - ~ext~ :: Functions from external sources.
    - ~oni~ :: Functions written personally.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (require 'ext)
      (require 'oni)
    #+END_SRC

*** Autoload

    These might not be used at all in a session, so they should only
    be loaded when necessary.

    =define-slime-contrib= was used by some module that didn't autoload
    or require it[fn:3].  But since I don't use whichever model it
    was every day, it is of no use to load it every single time.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'define-slime-contrib "slime")
    #+END_SRC

    I installed ~global~ with ~pacman~, but this doesn't add anything to
    any =loaddefs.el=, so doesn't create any autoloads.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'gtags-mode "gtags" nil t)
    #+END_SRC

    ~jabber.el~ does create ~jabber-autoloads.el~, but I only ever start
    using it through ~jabber-connect~, so anything else isn't really
    necessary.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'jabber-connect "jabber" nil t)
    #+END_SRC

    I used to work a bit on ~php-mode~, but that was a while ago, so
    it's still in my ~site-lisp~ directory.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'php-mode "php-mode" nil t)
    #+END_SRC

    The same that goes for ~gtags.el~ also goes for ~po-mode.el~.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'po-mode "po-mode" nil t)
    #+END_SRC

    And the same that went for ~php-mode~ also goes for ~pony-mode~,
    except I'm still working on it and I was too lazy to put it with
    my other projects.  I should still do that.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'pony-mode "pony-mode" nil t)
    #+END_SRC

    ~sawfish.el~ has the same problem that ~gtags.el~ and ~po-mode.el~ have.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'sawfish-mode "sawfish" nil t)
    #+END_SRC

    I use =server-running-p= to check whether or not I should start a
    new server, but this function isn't autoloaded by default.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'server-running-p "server")
    #+END_SRC

    I was starting to try ~slime-js~ to make JavaScript programming
    more interesting, but I haven't gotten around to trying it out
    fully, yet. It shares issues with ~gtags.el~, ~po-mode.el~ and
    ~sawfish.el~.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'slime-js-minor-mode "slime-js" nil t)
    #+END_SRC

    I found ~xmodmap-mode~ on the [[http://emacswiki.org][EmacsWiki]] some time ago, it was
    simple and a good example of how to use ~define-generic-mode~, but
    since it's not really my project and it's really small it just
    sits in my ~site-lisp~ directory.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'xmodmap-mode "xmodmap-mode" nil t)
    #+END_SRC

    ~w3m~ also has a setup module like ~geiser-install~, but since I only
    ever use these two functions to start it, there is no real need
    for anything else.

    #+BEGIN_SRC emacs-lisp :tangle init2.el
      (autoload 'w3m-bookmark-view "w3m" nil t)
      (autoload 'w3m-goto-url "w3m" nil t)
    #+END_SRC

* Aliases

  I've never had any trouble with accidentally pressing ~y~ while being
  asked a question, so I've never had any reason to prefer ~yes-or-no-p~
  over ~y-or-n-p~.

  #+begin_src emacs-lisp :tangle init2.el
    (defalias 'yes-or-no-p 'y-or-n-p)
  #+end_src

  ~ibuffer~ is a drop-in replacement for ~list-buffers~, but with more
  features.

  #+begin_src emacs-lisp :tangle init2.el
    (defalias 'list-buffers 'ibuffer)
  #+end_src

  I don't know if replacing ~dabbrev-expand~ with ~hippie-expand~, but at
  least ~hippie-expand~ doesn't use ~dabbrev-expand~, and I haven't
  noticed anything wrong so far, and ~hippie-expand~ does so much more
  than ~dabbrev-expand~.

  #+BEGIN_SRC emacs-lisp :tangle init2.el
    (defalias 'dabbrev-expand 'hippie-expand)
  #+END_SRC

* Faces

  Define a face to how the summary line of git commits as the first
  headline of an ~org-mode~ file.

  #+begin_src emacs-lisp :tangle init2.el
    (defface git-commit-summary-face
      '((t (:inherit org-level-1)))
      "Face for the git title line."
      :group 'local)
  #+end_src

  Define a face to show characters that have been placed beyond the
  maximum length of a summary line.

  #+begin_src emacs-lisp :tangle init2.el
    (defface git-commit-overlong-summary-face
      '((t (:background "#873732")))
      "Face for commit titles that are too long."
      :group 'local)
  #+end_src

  Define a face to show characters that have been placed on the second
  line of a git commit.  Those should always remain empty.

  #+BEGIN_SRC emacs-lisp :tangle init2.el
    (defface git-commit-nonempty-second-line-face
      '((t (:inherit git-commit-overlong-summary-face)))
      "Face for the supposedly empty line in commit messages."
      :group 'local)
  #+END_SRC

* Keys

   Since the ~C-l~ combination is so much easier than ~C-j~ when using the
   [[http://colemak.com][colemak]] keyboard layout and I use ~C-j~ much more, switch them.

   #+BEGIN_SRC emacs-lisp tangle init2.el
     (define-key key-translation-map (kbd "C-j") (kbd "C-l"))
     (define-key key-translation-map (kbd "C-l") (kbd "C-j"))
   #+END_SRC

* eldoc

  Diminish ~eldoc~'s lighter to nothing after it loads to keep the
  mode-line clean.

  #+begin_src emacs-lisp :tangle init2.el
    (eval-after-load "eldoc"
      '(diminish 'eldoc-mode))
  #+end_src

* eshell

  After ~em-term.el~ loads add ~unison~ to the ~eshell-visual-commands~ to
  make sure it gets unbuffered input.

  #+begin_src emacs-lisp :tangle init2.el
    (eval-after-load "em-term"
      '(add-to-list 'eshell-visual-commands "unison"))
  #+end_src

* Footnotes

[fn:1] Though it doesn't happen often that ~trunk~ is so messed up that
I can't use it.

[fn:2] Or perhaps all.

[fn:3] I think it was ~slime-js-minor-mode~, but I'm not sure.