fiddlerwoaroof/dotfiles - Change IOVPOFAVXEQIZ7BCFVVAWFW3RYFXPK2GOILDWA6N6QHQHLAJ4XTAC

rename emacs to init.el, add compatibility symlink

Created by Ed L on July 8, 2017

IOVPOFAVXEQIZ7BCFVVAWFW3RYFXPK2GOILDWA6N6QHQHLAJ4XTAC

Dependencies

In channels

main

Change contents

File deletion: dependencies, dependencies
BFD:BFD[6.1] → [7.129:152]
BFD:BFD[6.1] → [7.129:152]
BFD:BFD[7.152] → [7.128:128]

File addition: init.el (----------)

[4.131]

;;;; -*- mode: Emacs-Lisp;-*-
(setq default-directory "~/emacs-home/")
(make-directory default-directory t)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-to-load-path '("."))
  (normal-top-level-add-subdirs-to-load-path))
(setq vc-follow-symlinks t)
(require 'package)
(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
			 ("org" . "http://orgmode.org/elpa/")
			 ("melpa" . "https://melpa.org/packages/")
			 ("melpa-stable" . "http://stable.melpa.org/packages/"))
      package-archive-priorities '(("melpa-stable" . 1)
                                   ("gnu" . 0)
                                   ("melpa" . 2)
                                   ("org" . 3)))
(package-initialize)
(when (not (package-installed-p 'use-package))
  (package-refresh-contents)
  (package-install 'use-package))
(require 'use-package)
(use-package evil
  :ensure t
  :config
  (define-key evil-normal-state-map " o" 'slime-selector)
  (define-key evil-insert-state-map (kbd "TAB") 'company-complete)
  (use-package lisp-skeletons
    :ensure t
    :config
    (add-hook 'skeleton-end-hook 'skeleton-make-markers))
  (defun helm-generate-lisp-skeleton ()
    (interactive)
    (let ((skeletons '(("defunction" . skel-defun)
                       ("defmacro" . skel-defmacro)
                       ("defparameter" . skel-defparameter)
                       ("defvar" . skel-defvar))))
      (funcall (helm-comp-read "code template: " skeletons))))
  
  (define-key evil-normal-state-map " g" 'helm-generate-lisp-skeleton)
  (define-key evil-visual-state-map " g" 'helm-generate-lisp-skeleton)
  )
;;;;; INDENTATION SETUP  {{{
(progn
  (setq-default indent-tabs-mode nil
                tab-width 2)
  (defvaralias 'c-basic-offset 'tab-width)
  (defvaralias 'sh-basic-offset 'tab-width)
  (defvaralias 'js2-basic-offset 'tab-width)
  (defvaralias 'sgml-basic-offset 'tab-width)
  (defvaralias 'cperl-indent-level 'tab-width))
;;;;; }}}
;;;;; SLIME SETUP {{{
(progn ;slime isn't loaded via use-package because quicklisp-helper keeps it uptodate
  (load (expand-file-name "~/quicklisp/slime-helper.el"))
  ;; Replace "sbcl" with the path to your implementation
  (setq inferior-lisp-program "~/sbcl/bin/sbcl")
  (defun slime-ecl ()
    (interactive)
    (let ((inferior-lisp-program "ecl"))
      (slime)))
  (defun slime-cmucl ()
    (interactive)
    (let ((inferior-lisp-program "cmucl"))
      (slime)))
  (defun slime-sbcl ()
    (interactive)
    (let ((inferior-lisp-program "sbcl"))
      (slime)))
  (defun slime-ccl ()
    (interactive)
    (let ((inferior-lisp-program "ccl"))
      (slime)))
  (add-hook 'lisp-mode-hook
	    '(lambda ()
	       ;;(define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
	       (unless (string= "*slime-scratch*" (buffer-name))
		 (paredit-mode)
		 (evil-paredit-mode))
	       (rainbow-delimiters-mode))) 
  (setq slime-contribs
	'(slime-fancy
	  slime-company
	  slime-macrostep
	  slime-trace-dialog
	  slime-mdot-fu)))
(use-package slime-company
  :no-require t
  :defer t
  :ensure t)
;;;;; }}}
(use-package company
  :ensure t
  :config
  ;; keybindings
  (progn (define-key company-active-map (kbd "C-c h") 'company-quickhelp-manual-begin)
	 (define-key company-active-map (kbd "SPC") (kbd "RET SPC"))
	 (define-key company-active-map (kbd "(") (kbd "RET SPC ("))
	 (define-key company-active-map (kbd "{") (kbd "RET SPC {"))
	 (define-key company-active-map (kbd "[") (kbd "RET [")))
  (message "backends: %s" company-backends)
  (setq company-backends
	'(company-clang
	  company-bbdb
	  company-nxml
	  company-css
	  company-xcode
	  company-cmake
	  company-capf
	  company-files
	  (company-dabbrev-code
	   company-gtags
	   company-etags
	   company-keywords)
	  company-oddmuse
	  company-dabbrev))
  )
;; NOTE: this must be here...
(slime-setup)
(global-company-mode 1)
(use-package projectile
  :ensure t)
(use-package sbt-mode
  :ensure t
  :pin melpa-stable)
(use-package scala-mode
  :ensure t
  :pin melpa-stable)
(use-package ensime
  :ensure t)
(use-package intero
  :ensure t)
;; (use-package jdee
;;   :ensure t)
(use-package mvn
  :ensure t)
(use-package css-eldoc
  :ensure t)
(use-package ag
  :ensure t)
(use-package evil-vimish-fold
  :ensure t
  :config
  (evil-vimish-fold-mode 1))
(use-package zenburn-theme
  :ensure t)
(use-package zeal-at-point
  :ensure t)
(use-package rainbow-delimiters
  :ensure t)
(use-package tabbar
  :ensure t)
(use-package helm
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package evil-visual-mark-mode
  :ensure t)
(advice-add 'evil-delete-marks :after
	    (lambda (&rest args)
	      (evil-visual-mark-render)))
(use-package evil-nerd-commenter
  :ensure t
  :config
  (evilnc-default-hotkeys t))
(use-package paredit
  :ensure t
  :config
  (defun paredit-wiggle-back ()
    (paredit-forward)
    (paredit-backward))
  (defmacro defparedit-wrapper (name invoked-wrapper)
    `(defun ,name ()
       (interactive)
       (paredit-wiggle-back)
       (,invoked-wrapper)))
  (defparedit-wrapper back-then-wrap paredit-wrap-sexp)
  (defparedit-wrapper back-then-wrap-square paredit-wrap-square)
  (defparedit-wrapper back-then-wrap-curly paredit-wrap-curly)
  (defparedit-wrapper back-then-wrap-angled paredit-wrap-angled)
  (defparedit-wrapper back-then-wrap-doublequote paredit-meta-doublequote)
  (define-key evil-normal-state-map ",W" 'back-then-wrap)
  (define-key evil-normal-state-map ",w]" 'back-then-wrap-square)
  (define-key evil-normal-state-map ",w}" 'back-then-wrap-curly)
  (define-key evil-normal-state-map ",w>" 'back-then-wrap-angled)
  (define-key evil-normal-state-map ",w\"" 'back-then-wrap-doublequote)
  (define-key evil-normal-state-map ",S" 'paredit-splice-sexp)
  (define-key evil-normal-state-map ",A" 'paredit-splice-sexp-killing-backward)
  (define-key evil-normal-state-map ",D" 'paredit-splice-sexp-killing-forward)
  (define-key evil-normal-state-map ",|" 'paredit-split-sexp)
  (define-key evil-normal-state-map ",J" 'paredit-join-sexps)
  (define-key evil-normal-state-map ",<" 'paredit-backward-slurp-sexp)
  (define-key evil-normal-state-map ",," 'paredit-backward-barf-sexp) 
  (define-key evil-normal-state-map ",>" 'paredit-forward-slurp-sexp)
  (define-key evil-normal-state-map ",." 'paredit-forward-barf-sexp) 
  (define-key evil-normal-state-map ",~" 'paredit-convolute-sexp))
(use-package  evil-paredit
  :ensure t)
(use-package evil-numbers
  :ensure t
  :config
  (global-set-key (kbd "C-c +") 'evil-numbers/inc-at-pt)
  (global-set-key (kbd "C-c -") 'evil-numbers/dec-at-pt))
(use-package eldoc-eval
  :ensure t)
(use-package editorconfig
  :ensure t
  :config
  (editorconfig-mode 1))
(use-package csv-mode
  :ensure t)
(use-package color-theme
  :ensure t)
(use-package ansible
  :ensure t)
(use-package alect-themes
  :ensure t)
(use-package ac-js2
  :ensure t)
(use-package yaml-mode
  :ensure t)
(use-package web-mode
  :ensure t)
(use-package vue-mode
  :ensure t)
(use-package typescript-mode
  :ensure t)
(use-package scss-mode
  :ensure t)
(use-package rust-mode
  :ensure t)
(use-package  markdown-mode
  :ensure t)
(use-package magit
  :ensure t)
(use-package highlight-parentheses
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package helm-ls-git
  :ensure t)
;;(use-package helm-git
;;  :ensure t)
(use-package helm-css-scss
  :ensure t)
(use-package helm-cider
  :ensure t)
(use-package helm-ag-r
  :ensure t)
(use-package helm-ag
  :ensure t)
(use-package evil-surround
  :ensure t)
(use-package evil-leader
  :ensure t)
(use-package emmet-mode
  :ensure t)
(use-package project-explorer
  :ensure t
  )
(use-package ggtags
  :ensure t
  :config
  (ggtags-mode 1)
  (add-hook 'c-mode-common-hook
	    (lambda ()
	      (when (derived-mode-p 'c-mode 'c++-mode 'java-mode 'asm-mode)
		(ggtags-mode 1)))))
(use-package pollen-mode
  :config
  (defun insert-lozenge ()
    (interactive)
    (insert-char 9674))
  (define-key evil-insert-state-map (kbd "C-c C-l") 'insert-lozenge))
(progn ; helm
  (require 'helm-config)
  (helm-mode)
  (global-set-key (kbd "C-x C-f") 'helm-find-files)
  (define-key evil-normal-state-map " f" 'helm-projectile)
  (define-key evil-normal-state-map " j" 'helm-buffers-list)
  (global-set-key (kbd "M-x") 'helm-M-x))
(require 'js2-mode)
(require 'projectile)
(projectile-mode)
(add-hook 'after-init-hook
	  (lambda ()
	    (unless (server-running-p)
	      (server-start))
	    (evil-mode)
	    (paredit-mode)
	    (evil-paredit-mode)
	    (global-company-mode)
	    (global-linum-mode)))
(progn ; linum
  (setq linum-format "%5d\u2502"))
(require 'evil-numbers)
(define-key evil-normal-state-map "ZZ" 'save-buffer)
(define-key evil-normal-state-map ",zz" 'zeal-at-point)
(modify-syntax-entry ?_ "w" js-mode-syntax-table)
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?[ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?] "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?{ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?} "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" emacs-lisp-mode-syntax-table)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-subdirs-to-load-path))
(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.
 '(default ((t (:family "Source Code Pro" :foundry "adobe" :slant normal :weight semi-bold :height 113 :width normal)))))
 
(setq erc-hide-list '("JOIN" "PART" "QUIT"))
;; (defun znc-erc ()
;;   (interactive)
;;   (erc-ssl :server "localhost" :port 6697 :nick "edwlan/freenode" :password "t31ch3rtb"))
(add-to-list 'auto-mode-alist '("\\.cljs\\.hl\\'" . clojurescript-mode))
(add-hook 'ruby-mode-hook
	  '(lambda ()
	     (eldoc-mode)
	     (robe-mode)))
(add-hook 'clojure-mode-hook
	  '(lambda ()
	     ;; Hoplon functions and macros
	     (paredit-mode)
	     (define-key evil-insert-state-map "^N" 'helm-cider-apropos)
	     (dolist (pair '((page . 'defun)
			     (loop-tpl . 'defun)
			     (if-tpl . '1)
			     (for-tpl . '1)
			     (case-tpl . '1)
			     (cond-tpl . 'defun)))
	       (put-clojure-indent (car pair)
				   (car (last pair))))))
(setq tls-program '("openssl s_client -connect %h:%p -no_ssl2 -ign_eof"))
(global-auto-revert-mode t)
 ;;; Use auto-complete for ensime
(defun scala/enable-eldoc ()
  "Show error message or type name at point by Eldoc."
  (setq-local eldoc-documentation-function
	      #'(lambda ()
		  (when (ensime-connected-p)
		    (let ((err (ensime-print-errors-at-point)))
		      (or (and err (not (string= err "")) err)
			  (ensime-print-type-at-point))))))
  (eldoc-mode +1))
(defun scala/completing-dot-company ()
  (cond (company-backend
	 (company-complete-selection)
	 (scala/completing-dot))
	(t
	 (insert ".")
	 (company-complete))))
(defun scala/completing-dot-ac ()
  (insert ".")
  (ac-trigger-key-command t))
;; Interactive commands
(defun scala/completing-dot ()
  "Insert a period and show company completions."
  (interactive "*")
  (eval-and-compile (require 'ensime))
  (eval-and-compile (require 's))
  (when (s-matches? (rx (+ (not space)))
		    (buffer-substring (line-beginning-position) (point)))
    (delete-horizontal-space t))
  (cond ((not (and (ensime-connected-p) ensime-completion-style))
	 (insert "."))
	((eq ensime-completion-style 'company)
	 (scala/completing-dot-company))
	((eq ensime-completion-style 'auto-complete)
	 (scala/completing-dot-ac))))
;; Initialization
(add-hook 'ensime-mode-hook #'scala/enable-eldoc)
(add-hook 'scala-mode-hook 'ensime-scala-mode-hook)
(add-hook 'scala-mode-hook 'flycheck-mode)
(add-hook 'haskell-mode-hook 'intero-mode)
(add-hook 'c-mode-common-hook
	  (lambda ()
	    (when (derived-mode-p 'c-mode 'c++-mode 'java-mode)
	      (semantic-mode 1)
	      
	      (global-semanticdb-minor-mode 1)
	      (global-semantic-idle-scheduler-mode 1)
	      (global-semantic-stickyfunc-mode 1)
	      
	      (helm-gtags-mode)
	      (ggtags-mode 1))))
(setq company-backends (delete 'company-semantic company-backends))
(defun alexott/cedet-hook ()
  (local-set-key "\C-c\C-j" 'semantic-ia-fast-jump)
  (local-set-key "\C-c\C-s" 'semantic-ia-show-summary))
(add-hook 'c-mode-common-hook 'alexott/cedet-hook)
(add-hook 'c-mode-hook 'alexott/cedet-hook)
(add-hook 'c++-mode-hook 'alexott/cedet-hook)
(defun set-exec-path-from-shell-PATH ()
  "Set up Emacs' `exec-path' and PATH environment variable to match that used by the user's shell.
 
 This is particularly useful under Mac OSX, where GUI apps are not started from a shell."
  (interactive)
  (let ((path-from-shell (replace-regexp-in-string "[ \t\n]*$" "" (shell-command-to-string "$SHELL --login -i -c 'echo $PATH'"))))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))
(set-exec-path-from-shell-PATH)
(require 'ede)
(global-ede-mode)
(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.
 '(ansi-color-faces-vector
   [default bold shadow italic underline bold bold-italic bold])
 '(ansi-color-names-vector
   ["#212526" "#ff4b4b" "#b4fa70" "#fce94f" "#729fcf" "#e090d7" "#8cc4ff" "#eeeeec"])
 '(browse-url-browser-function (quote browse-url-generic))
 '(browse-url-generic-program "x-www-browser")
 '(company-backends
   (quote
    (company-semantic company-bbdb company-nxml company-css company-xcode company-cmake company-capf company-files
                      (company-dabbrev-code company-gtags company-etags company-keywords)
                      company-oddmuse company-dabbrev)))
 '(custom-enabled-themes (quote (zenburn)))
 '(custom-safe-themes
   (quote
    ("f5512c02e0a6887e987a816918b7a684d558716262ac7ee2dd0437ab913eaec6" "9d91458c4ad7c74cf946bd97ad085c0f6a40c370ac0a1cbeb2e3879f15b40553" "4e753673a37c71b07e3026be75dc6af3efbac5ce335f3707b7d6a110ecb636a3" "4aee8551b53a43a883cb0b7f3255d6859d766b6c5e14bcb01bed572fcbef4328" "ab04c00a7e48ad784b52f34aa6bfa1e80d0c3fcacc50e1189af3651013eb0d58" "a0feb1322de9e26a4d209d1cfa236deaf64662bb604fa513cca6a057ddf0ef64" default)))
 '(erc-modules
   (quote
    (autoaway autojoin button capab-identify completion fill irccontrols list match menu move-to-prompt netsplit networks noncommands readonly ring stamp spelling track)))
 '(erc-truncate-mode t)
 '(evil-leader/leader ",")
 '(evil-visual-mark-mode t)
 '(font-use-system-font t)
 '(ggtags-sort-by-nearness t)
 '(ggtags-update-on-save t)
 '(global-evil-surround-mode t)
 '(global-linum-mode t)
 '(haskell-mode-hook
   (quote
    (capitalized-words-mode haskell-decl-scan-mode haskell-indentation-mode highlight-uses-mode imenu-add-menubar-index interactive-haskell-mode)) t)
 '(helm-ls-git-fuzzy-match t)
 '(jdee-server-dir "~/.emacs.d/jdee-server/")
 '(jira-url "https://atomampd.atlassian.net/rpc/xmlrpc")
 '(line-number-mode nil)
 '(mac-command-modifier nil)
 '(mac-option-modifier (quote meta))
 '(mac-pass-command-to-system t)
 '(nrepl-message-colors
   (quote
    ("#CC9393" "#DFAF8F" "#F0DFAF" "#7F9F7F" "#BFEBBF" "#93E0E3" "#94BFF3" "#DC8CC3")))
 '(package-selected-packages
   (quote
    (deft geiser pollen-mode js2-refactor npm-mode helm-dash aggressive-indent company-tern tern srefactor ac-slime znc helm-ag ag helm-projectile notmuch zenburn-theme zeal-at-point use-package tabbar slime-company rainbow-delimiters projectile mvn jdee intero helm evil-visual-mark-mode evil-vimish-fold evil-paredit evil-numbers ensime eldoc-eval editorconfig color-theme ansible alect-themes ac-js2)))
 '(pe/omit-gitignore t)
 '(safe-local-variable-values
   (quote
    ((company-clang-arguments "-I.")
     (Base . 10)
     (Package . CL-USER)
     (Syntax . COMMON-LISP))))
 '(slime-company-completion (quote fuzzy)))

Replacement in emacs.d/emacs at line 1 [8.82]

B:BD[8.82] → [9.83:114]

∅:D[9.114] → [8.83:161]

B:BD[8.82] → [8.83:161]

B:BD[8.161] → [3.131:311]

∅:D[3.311] → [9.115:143]

B:BD[8.161] → [9.115:143]

∅:D[9.143] → [8.161:395]

B:BD[8.161] → [8.161:395]

B:BD[8.395] → [10.83:284]

∅:D[10.284] → [8.453:522]

B:BD[8.453] → [8.453:522]

B:BD[8.522] → [11.83:112]

∅:D[11.112] → [8.522:678]

B:BD[8.522] → [8.522:678]

B:BD[8.678] → [3.312:978]

∅:D[3.978] → [12.47696:48025]

B:BD[9.212] → [12.47696:48025]

∅:D[9.212] → [10.725:726]

∅:D[12.48025] → [10.725:726]

B:BD[10.725] → [10.725:726]

B:BD[10.726] → [12.48026:48037]

∅:D[10.726] → [8.753:919]

∅:D[12.48037] → [8.753:919]

B:BD[8.753] → [8.753:919]

B:BD[8.919] → [11.113:220]

∅:D[11.220] → [8.919:1317]

B:BD[8.919] → [8.919:1317]

B:BD[8.1318] → [8.1318:1319]

B:BD[8.1436] → [8.1436:1647]

B:BD[8.1647] → [13.83:144]

B:BD[13.144] → [14.107:223]

∅:D[14.223] → [9.348:417]

B:BD[9.348] → [9.348:417]

∅:D[9.417] → [8.1674:1684]

B:BD[8.1674] → [8.1674:1684]

B:BD[8.1684] → [9.418:855]

B:BD[9.855] → [14.224:503]

∅:D[14.503] → [9.1131:1206]

B:BD[9.1131] → [9.1131:1206]

∅:D[9.1206] → [8.1684:1722]

B:BD[8.1684] → [8.1684:1722]

B:BD[8.1756] → [8.1756:1870]

B:BD[8.1870] → [11.221:255]

∅:D[11.255] → [8.1870:1904]

B:BD[8.1870] → [8.1870:1904]

B:BD[8.1904] → [9.1207:1244]

∅:D[9.1244] → [8.1935:2064]

B:BD[8.1935] → [8.1935:2064]

B:BD[8.2064] → [13.145:196]

∅:D[13.196] → [8.2077:2402]

B:BD[8.2077] → [8.2077:2402]

B:BD[8.2402] → [9.1245:1306]

B:BD[9.1306] → [13.197:198]

B:BD[13.198] → [14.504:590]

∅:D[14.590] → [13.198:1822]

B:BD[13.198] → [13.198:1822]

∅:D[9.1306] → [8.2481:2549]

∅:D[13.1822] → [8.2481:2549]

B:BD[8.2481] → [8.2481:2549]

B:BD[8.2549] → [13.1823:1960]

∅:D[13.1960] → [8.2562:2627]

B:BD[8.2562] → [8.2562:2627]

B:BD[8.2627] → [13.1961:2008]

∅:D[13.2008] → [8.2640:3257]

B:BD[8.2640] → [8.2640:3257]

B:BD[8.3257] → [13.2009:2048]

∅:D[9.1354] → [8.3294:3486]

∅:D[13.2048] → [8.3294:3486]

B:BD[8.3294] → [8.3294:3486]

∅:D[11.306] → [8.3533:3597]

∅:D[12.48068] → [8.3533:3597]

B:BD[8.3533] → [8.3533:3597]

B:BD[8.4038] → [8.4038:4051]

B:BD[8.4051] → [11.307:308]

B:BD[11.337] → [11.337:583]

B:BD[11.583] → [13.2049:2050]

∅:D[11.583] → [8.4051:4052]

∅:D[13.2050] → [8.4051:4052]

B:BD[8.4051] → [8.4051:4052]

∅:D[10.2591] → [8.6518:6519]

B:BD[8.6518] → [8.6518:6519]

B:BD[8.6519] → [13.2051:2225]

∅:D[13.2225] → [8.6519:6520]

B:BD[8.6519] → [8.6519:6520]

B:BD[8.6520] → [13.2226:2493]

∅:D[13.2493] → [8.6686:6687]

B:BD[8.6686] → [8.6686:6687]

B:BD[8.6722] → [8.6722:6742]

B:BD[8.6742] → [13.2494:2495]

∅:D[9.1371] → [8.6824:6864]

∅:D[11.1582] → [8.6824:6864]

∅:D[13.2495] → [8.6824:6864]

B:BD[8.6824] → [8.6824:6864]

B:BD[8.6891] → [8.6891:6892]

∅:D[11.1609] → [8.6994:6995]

B:BD[8.6994] → [8.6994:6995]

B:BD[8.7083] → [8.7083:7084]

B:BD[8.7084] → [2.2056:2268]

∅:D[2.2268] → [8.7136:7137]

∅:D[13.2721] → [8.7136:7137]

B:BD[8.7136] → [8.7136:7137]

B:BD[8.7137] → [13.2722:2772]

∅:D[13.2772] → [8.7376:7377]

B:BD[8.7376] → [8.7376:7377]

B:BD[8.7377] → [13.2773:2797]

∅:D[13.2797] → [8.7493:7547]

B:BD[8.7493] → [8.7493:7547]

B:BD[8.9072] → [8.9072:10710]

B:BD[8.10710] → [3.979:1103]

∅:D[15.341] → [8.10968:11223]

∅:D[14.714] → [8.10968:11223]

∅:D[3.1103] → [8.10968:11223]

∅:D[10.2714] → [8.10968:11223]

B:BD[8.10968] → [8.10968:11223]

B:BD[8.11273] → [8.11273:11756]

B:BD[8.11894] → [8.11894:11895]

B:BD[8.11997] → [8.11997:12101]

B:BD[8.12101] → [9.1372:1406]

∅:D[9.1406] → [8.12134:12262]

B:BD[8.12134] → [8.12134:12262]

B:BD[8.12262] → [9.1407:1596]

∅:D[9.1596] → [8.12521:12605]

B:BD[8.12521] → [8.12521:12605]

B:BD[8.12605] → [9.1597:1697]

∅:D[9.1697] → [8.12740:13061]

B:BD[8.12740] → [8.12740:13061]

B:BD[8.13061] → [9.1698:1758]

∅:D[9.1758] → [8.13135:13234]

B:BD[8.13135] → [8.13135:13234]

B:BD[8.13234] → [9.1759:1926]

∅:D[9.1926] → [8.13436:13643]

B:BD[8.13436] → [8.13436:13643]

B:BD[8.13643] → [11.1626:1657]

B:BD[11.1657] → [9.1927:1941]

∅:D[9.1941] → [11.1678:1735]

B:BD[11.1678] → [11.1678:1735]

B:BD[11.1735] → [13.2798:2831]

∅:D[13.2831] → [11.1735:1865]

B:BD[11.1735] → [11.1735:1865]

B:BD[11.1865] → [9.1942:1950]

∅:D[9.1959] → [11.1892:2293]

B:BD[11.1892] → [11.1892:2293]

B:BD[11.2293] → [16.99:238]

B:BD[16.238] → [9.1960:2052]

∅:D[9.2052] → [16.328:613]

B:BD[16.328] → [16.328:613]

∅:D[16.613] → [11.2293:2326]

B:BD[11.2293] → [11.2293:2326]

B:BD[11.2326] → [16.614:615]

B:BD[16.615] → [9.2053:2390]

B:BD[9.2390] → [15.342:455]

∅:D[15.455] → [9.2390:2496]

B:BD[9.2390] → [9.2390:2496]

B:BD[9.2496] → [15.456:601]

B:BD[15.601] → [3.1104:1251]

∅:D[15.720] → [9.2496:2572]

∅:D[3.1251] → [9.2496:2572]

B:BD[9.2496] → [9.2496:2572]

B:BD[9.2572] → [15.721:1139]

∅:D[15.1139] → [9.2923:3226]

B:BD[9.2923] → [9.2923:3226]

B:BD[9.3226] → [15.1140:1198]

∅:D[15.1198] → [9.3226:3313]

B:BD[9.3226] → [9.3226:3313]

B:BD[9.3313] → [3.1252:1402]

∅:D[15.1349] → [9.3461:3491]

∅:D[3.1402] → [9.3461:3491]

∅:D[12.48217] → [9.3461:3491]

B:BD[9.3461] → [9.3461:3491]

B:BD[9.3491] → [15.1350:1396]

∅:D[15.1396] → [9.3491:3573]

B:BD[9.3491] → [9.3491:3573]

B:BD[9.3573] → [15.1397:1618]

∅:D[15.1618] → [9.3573:3612]

B:BD[9.3573] → [9.3573:3612]

B:BD[9.3612] → [12.48218:48624]

∅:D[13.3233] → [15.2001:2025]

∅:D[12.48624] → [15.2001:2025]

B:BD[15.2001] → [15.2001:2025]

∅:D[15.2025] → [9.4445:4485]

B:BD[9.4445] → [9.4445:4485]

B:BD[9.4485] → [15.2026:2063]

∅:D[15.2063] → [9.4534:4551]

B:BD[9.4534] → [9.4534:4551]

B:BD[9.4551] → [15.2064:2089]

∅:D[15.2089] → [9.4582:4613]

B:BD[9.4582] → [9.4582:4613]

B:BD[9.4613] → [15.2090:2134]

;;;; -*- mode: Emacs-Lisp;-*-
(setq default-directory "~/emacs-home/")
(make-directory default-directory t)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-to-load-path '("."))
  (normal-top-level-add-subdirs-to-load-path))
(setq vc-follow-symlinks t)
(require 'package)
(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
			 ("org" . "http://orgmode.org/elpa/")
			 ("melpa" . "https://melpa.org/packages/")
			 ("melpa-stable" . "http://stable.melpa.org/packages/"))
      package-archive-priorities '(("melpa-stable" . 1)
                                   ("gnu" . 0)
                                   ("melpa" . 2)
                                   ("org" . 3)))
(package-initialize)
(when (not (package-installed-p 'use-package))
  (package-refresh-contents)
  (package-install 'use-package))
(require 'use-package)
(use-package evil
  :ensure t
  :config
  (define-key evil-normal-state-map " o" 'slime-selector)
  (define-key evil-insert-state-map (kbd "TAB") 'company-complete)
  (use-package lisp-skeletons
    :ensure t
    :config
    (add-hook 'skeleton-end-hook 'skeleton-make-markers))
  (defun helm-generate-lisp-skeleton ()
    (interactive)
    (let ((skeletons '(("defunction" . skel-defun)
                       ("defmacro" . skel-defmacro)
                       ("defparameter" . skel-defparameter)
                       ("defvar" . skel-defvar))))
      (funcall (helm-comp-read "code template: " skeletons))))
  
  (define-key evil-normal-state-map " g" 'helm-generate-lisp-skeleton)
  (define-key evil-visual-state-map " g" 'helm-generate-lisp-skeleton)
  )
;;;;; INDENTATION SETUP  {{{
(progn
  (setq-default indent-tabs-mode nil
                tab-width 2)
  (defvaralias 'c-basic-offset 'tab-width)
  (defvaralias 'sh-basic-offset 'tab-width)
  (defvaralias 'js2-basic-offset 'tab-width)
  (defvaralias 'sgml-basic-offset 'tab-width)
  (defvaralias 'cperl-indent-level 'tab-width))
;;;;; }}}
;;;;; SLIME SETUP {{{
(progn ;slime isn't loaded via use-package because quicklisp-helper keeps it uptodate
  (load (expand-file-name "~/quicklisp/slime-helper.el"))
  ;; Replace "sbcl" with the path to your implementation
  (setq inferior-lisp-program "~/sbcl/bin/sbcl")
  (defun slime-ecl ()
    (interactive)
    (let ((inferior-lisp-program "ecl"))
      (slime)))
  (defun slime-cmucl ()
    (interactive)
    (let ((inferior-lisp-program "cmucl"))
      (slime)))
  (defun slime-sbcl ()
    (interactive)
    (let ((inferior-lisp-program "sbcl"))
      (slime)))
  (defun slime-ccl ()
    (interactive)
    (let ((inferior-lisp-program "ccl"))
      (slime)))
  (add-hook 'lisp-mode-hook
	    '(lambda ()
	       ;;(define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
	       (unless (string= "*slime-scratch*" (buffer-name))
		 (paredit-mode)
		 (evil-paredit-mode))
	       (rainbow-delimiters-mode))) 
  (setq slime-contribs
	'(slime-fancy
	  slime-company
	  slime-macrostep
	  slime-trace-dialog
	  slime-mdot-fu)))
(use-package slime-company
  :no-require t
  :defer t
  :ensure t)
;;;;; }}}
(use-package company
  :ensure t
  :config
  ;; keybindings
  (progn (define-key company-active-map (kbd "C-c h") 'company-quickhelp-manual-begin)
	 (define-key company-active-map (kbd "SPC") (kbd "RET SPC"))
	 (define-key company-active-map (kbd "(") (kbd "RET SPC ("))
	 (define-key company-active-map (kbd "{") (kbd "RET SPC {"))
	 (define-key company-active-map (kbd "[") (kbd "RET [")))
  (message "backends: %s" company-backends)
  (setq company-backends
	'(company-clang
	  company-bbdb
	  company-nxml
	  company-css
	  company-xcode
	  company-cmake
	  company-capf
	  company-files
	  (company-dabbrev-code
	   company-gtags
	   company-etags
	   company-keywords)
	  company-oddmuse
	  company-dabbrev))
  )
;; NOTE: this must be here...
(slime-setup)
(global-company-mode 1)
(use-package projectile
  :ensure t)
(use-package sbt-mode
  :ensure t
  :pin melpa-stable)
(use-package scala-mode
  :ensure t
  :pin melpa-stable)
(use-package ensime
  :ensure t)
(use-package intero
  :ensure t)
;; (use-package jdee
;;   :ensure t)
(use-package mvn
  :ensure t)
(use-package css-eldoc
  :ensure t)
(use-package ag
  :ensure t)
(use-package evil-vimish-fold
  :ensure t
  :config
  (evil-vimish-fold-mode 1))
(use-package zenburn-theme
  :ensure t)
(use-package zeal-at-point
  :ensure t)
(use-package rainbow-delimiters
  :ensure t)
(use-package tabbar
  :ensure t)
(use-package helm
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package evil-visual-mark-mode
  :ensure t)
(advice-add 'evil-delete-marks :after
	    (lambda (&rest args)
	      (evil-visual-mark-render)))
(use-package evil-nerd-commenter
  :ensure t
  :config
  (evilnc-default-hotkeys t))
(use-package paredit
  :ensure t
  :config
  (defun paredit-wiggle-back ()
    (paredit-forward)
    (paredit-backward))
  (defmacro defparedit-wrapper (name invoked-wrapper)
    `(defun ,name ()
       (interactive)
       (paredit-wiggle-back)
       (,invoked-wrapper)))
  (defparedit-wrapper back-then-wrap paredit-wrap-sexp)
  (defparedit-wrapper back-then-wrap-square paredit-wrap-square)
  (defparedit-wrapper back-then-wrap-curly paredit-wrap-curly)
  (defparedit-wrapper back-then-wrap-angled paredit-wrap-angled)
  (defparedit-wrapper back-then-wrap-doublequote paredit-meta-doublequote)
  (define-key evil-normal-state-map ",W" 'back-then-wrap)
  (define-key evil-normal-state-map ",w]" 'back-then-wrap-square)
  (define-key evil-normal-state-map ",w}" 'back-then-wrap-curly)
  (define-key evil-normal-state-map ",w>" 'back-then-wrap-angled)
  (define-key evil-normal-state-map ",w\"" 'back-then-wrap-doublequote)
  (define-key evil-normal-state-map ",S" 'paredit-splice-sexp)
  (define-key evil-normal-state-map ",A" 'paredit-splice-sexp-killing-backward)
  (define-key evil-normal-state-map ",D" 'paredit-splice-sexp-killing-forward)
  (define-key evil-normal-state-map ",|" 'paredit-split-sexp)
  (define-key evil-normal-state-map ",J" 'paredit-join-sexps)
  (define-key evil-normal-state-map ",<" 'paredit-backward-slurp-sexp)
  (define-key evil-normal-state-map ",," 'paredit-backward-barf-sexp) 
  (define-key evil-normal-state-map ",>" 'paredit-forward-slurp-sexp)
  (define-key evil-normal-state-map ",." 'paredit-forward-barf-sexp) 
  (define-key evil-normal-state-map ",~" 'paredit-convolute-sexp))
(use-package  evil-paredit
  :ensure t)
(use-package evil-numbers
  :ensure t
  :config
  (global-set-key (kbd "C-c +") 'evil-numbers/inc-at-pt)
  (global-set-key (kbd "C-c -") 'evil-numbers/dec-at-pt))
(use-package eldoc-eval
  :ensure t)
(use-package editorconfig
  :ensure t
  :config
  (editorconfig-mode 1))
(use-package csv-mode
  :ensure t)
(use-package color-theme
  :ensure t)
(use-package ansible
  :ensure t)
(use-package alect-themes
  :ensure t)
(use-package ac-js2
  :ensure t)
(use-package yaml-mode
  :ensure t)
(use-package web-mode
  :ensure t)
(use-package vue-mode
  :ensure t)
(use-package typescript-mode
  :ensure t)
(use-package scss-mode
  :ensure t)
(use-package rust-mode
  :ensure t)
(use-package  markdown-mode
  :ensure t)
(use-package magit
  :ensure t)
(use-package highlight-parentheses
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package helm-ls-git
  :ensure t)
;;(use-package helm-git
;;  :ensure t)
(use-package helm-css-scss
  :ensure t)
(use-package helm-cider
  :ensure t)
(use-package helm-ag-r
  :ensure t)
(use-package helm-ag
  :ensure t)
(use-package evil-surround
  :ensure t)
(use-package evil-leader
  :ensure t)
(use-package emmet-mode
  :ensure t)
(use-package project-explorer
  :ensure t
  )
(use-package ggtags
  :ensure t
  :config
  (ggtags-mode 1)
  (add-hook 'c-mode-common-hook
	    (lambda ()
	      (when (derived-mode-p 'c-mode 'c++-mode 'java-mode 'asm-mode)
		(ggtags-mode 1)))))
(use-package pollen-mode
  :config
  (defun insert-lozenge ()
    (interactive)
    (insert-char 9674))
  (define-key evil-insert-state-map (kbd "C-c C-l") 'insert-lozenge))
(progn ; helm
  (require 'helm-config)
  (helm-mode)
  (global-set-key (kbd "C-x C-f") 'helm-find-files)
  (define-key evil-normal-state-map " f" 'helm-projectile)
  (define-key evil-normal-state-map " j" 'helm-buffers-list)
  (global-set-key (kbd "M-x") 'helm-M-x))
(require 'js2-mode)
(require 'projectile)
(projectile-mode)
(add-hook 'after-init-hook
	  (lambda ()
	    (unless (server-running-p)
	      (server-start))
	    (evil-mode)
	    (paredit-mode)
	    (evil-paredit-mode)
	    (global-company-mode)
	    (global-linum-mode)))
(progn ; linum
  (setq linum-format "%5d\u2502"))
(require 'evil-numbers)
(define-key evil-normal-state-map "ZZ" 'save-buffer)
(define-key evil-normal-state-map ",zz" 'zeal-at-point)
(modify-syntax-entry ?_ "w" js-mode-syntax-table)
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?[ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?] "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?{ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?} "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" emacs-lisp-mode-syntax-table)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-subdirs-to-load-path))
(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.
 '(default ((t (:family "Source Code Pro" :foundry "adobe" :slant normal :weight semi-bold :height 113 :width normal)))))
 
(setq erc-hide-list '("JOIN" "PART" "QUIT"))
;; (defun znc-erc ()
;;   (interactive)
;;   (erc-ssl :server "localhost" :port 6697 :nick "edwlan/freenode" :password "t31ch3rtb"))
(add-to-list 'auto-mode-alist '("\\.cljs\\.hl\\'" . clojurescript-mode))
(add-hook 'ruby-mode-hook
	  '(lambda ()
	     (eldoc-mode)
	     (robe-mode)))
(add-hook 'clojure-mode-hook
	  '(lambda ()
	     ;; Hoplon functions and macros
	     (paredit-mode)
	     (define-key evil-insert-state-map "^N" 'helm-cider-apropos)
	     (dolist (pair '((page . 'defun)
			     (loop-tpl . 'defun)
			     (if-tpl . '1)
			     (for-tpl . '1)
			     (case-tpl . '1)
			     (cond-tpl . 'defun)))
	       (put-clojure-indent (car pair)
				   (car (last pair))))))
(setq tls-program '("openssl s_client -connect %h:%p -no_ssl2 -ign_eof"))
(global-auto-revert-mode t)
 ;;; Use auto-complete for ensime
(defun scala/enable-eldoc ()
  "Show error message or type name at point by Eldoc."
  (setq-local eldoc-documentation-function
	      #'(lambda ()
		  (when (ensime-connected-p)
		    (let ((err (ensime-print-errors-at-point)))
		      (or (and err (not (string= err "")) err)
			  (ensime-print-type-at-point))))))
  (eldoc-mode +1))
(defun scala/completing-dot-company ()
  (cond (company-backend
	 (company-complete-selection)
	 (scala/completing-dot))
	(t
	 (insert ".")
	 (company-complete))))
(defun scala/completing-dot-ac ()
  (insert ".")
  (ac-trigger-key-command t))
;; Interactive commands
(defun scala/completing-dot ()
  "Insert a period and show company completions."
  (interactive "*")
  (eval-and-compile (require 'ensime))
  (eval-and-compile (require 's))
  (when (s-matches? (rx (+ (not space)))
		    (buffer-substring (line-beginning-position) (point)))
    (delete-horizontal-space t))
  (cond ((not (and (ensime-connected-p) ensime-completion-style))
	 (insert "."))
	((eq ensime-completion-style 'company)
	 (scala/completing-dot-company))
	((eq ensime-completion-style 'auto-complete)
	 (scala/completing-dot-ac))))
;; Initialization
(add-hook 'ensime-mode-hook #'scala/enable-eldoc)
(add-hook 'scala-mode-hook 'ensime-scala-mode-hook)
(add-hook 'scala-mode-hook 'flycheck-mode)
(add-hook 'haskell-mode-hook 'intero-mode)
(add-hook 'c-mode-common-hook
	  (lambda ()
	    (when (derived-mode-p 'c-mode 'c++-mode 'java-mode)
	      (semantic-mode 1)
	      
	      (global-semanticdb-minor-mode 1)
	      (global-semantic-idle-scheduler-mode 1)
	      (global-semantic-stickyfunc-mode 1)
	      
	      (helm-gtags-mode)
	      (ggtags-mode 1))))
(setq company-backends (delete 'company-semantic company-backends))
(defun alexott/cedet-hook ()
  (local-set-key "\C-c\C-j" 'semantic-ia-fast-jump)
  (local-set-key "\C-c\C-s" 'semantic-ia-show-summary))
(add-hook 'c-mode-common-hook 'alexott/cedet-hook)
(add-hook 'c-mode-hook 'alexott/cedet-hook)
(add-hook 'c++-mode-hook 'alexott/cedet-hook)
(defun set-exec-path-from-shell-PATH ()
  "Set up Emacs' `exec-path' and PATH environment variable to match that used by the user's shell.
 
 This is particularly useful under Mac OSX, where GUI apps are not started from a shell."
  (interactive)
  (let ((path-from-shell (replace-regexp-in-string "[ \t\n]*$" "" (shell-command-to-string "$SHELL --login -i -c 'echo $PATH'"))))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))
(set-exec-path-from-shell-PATH)
(require 'ede)
(global-ede-mode)
(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.
 '(ansi-color-faces-vector
   [default bold shadow italic underline bold bold-italic bold])
 '(ansi-color-names-vector
   ["#212526" "#ff4b4b" "#b4fa70" "#fce94f" "#729fcf" "#e090d7" "#8cc4ff" "#eeeeec"])
 '(browse-url-browser-function (quote browse-url-generic))
 '(browse-url-generic-program "x-www-browser")
 '(company-backends
   (quote
    (company-semantic company-bbdb company-nxml company-css company-xcode company-cmake company-capf company-files
                      (company-dabbrev-code company-gtags company-etags company-keywords)
                      company-oddmuse company-dabbrev)))
 '(custom-enabled-themes (quote (zenburn)))
 '(custom-safe-themes
   (quote
    ("f5512c02e0a6887e987a816918b7a684d558716262ac7ee2dd0437ab913eaec6" "9d91458c4ad7c74cf946bd97ad085c0f6a40c370ac0a1cbeb2e3879f15b40553" "4e753673a37c71b07e3026be75dc6af3efbac5ce335f3707b7d6a110ecb636a3" "4aee8551b53a43a883cb0b7f3255d6859d766b6c5e14bcb01bed572fcbef4328" "ab04c00a7e48ad784b52f34aa6bfa1e80d0c3fcacc50e1189af3651013eb0d58" "a0feb1322de9e26a4d209d1cfa236deaf64662bb604fa513cca6a057ddf0ef64" default)))
 '(erc-modules
   (quote
    (autoaway autojoin button capab-identify completion fill irccontrols list match menu move-to-prompt netsplit networks noncommands readonly ring stamp spelling track)))
 '(erc-truncate-mode t)
 '(evil-leader/leader ",")
 '(evil-visual-mark-mode t)
 '(font-use-system-font t)
 '(ggtags-sort-by-nearness t)
 '(ggtags-update-on-save t)
 '(global-evil-surround-mode t)
 '(global-linum-mode t)
 '(haskell-mode-hook
   (quote
    (capitalized-words-mode haskell-decl-scan-mode haskell-indentation-mode highlight-uses-mode imenu-add-menubar-index interactive-haskell-mode)) t)
 '(helm-ls-git-fuzzy-match t)
 '(jdee-server-dir "~/.emacs.d/jdee-server/")
 '(jira-url "https://atomampd.atlassian.net/rpc/xmlrpc")
 '(line-number-mode nil)
 '(mac-command-modifier nil)
 '(mac-option-modifier (quote meta))
 '(mac-pass-command-to-system t)
 '(nrepl-message-colors
   (quote
    ("#CC9393" "#DFAF8F" "#F0DFAF" "#7F9F7F" "#BFEBBF" "#93E0E3" "#94BFF3" "#DC8CC3")))
 '(package-selected-packages
   (quote
    (deft geiser pollen-mode js2-refactor npm-mode helm-dash aggressive-indent company-tern tern srefactor ac-slime znc helm-ag ag helm-projectile notmuch zenburn-theme zeal-at-point use-package tabbar slime-company rainbow-delimiters projectile mvn jdee intero helm evil-visual-mark-mode evil-vimish-fold evil-paredit evil-numbers ensime eldoc-eval editorconfig color-theme ansible alect-themes ac-js2)))
 '(pe/omit-gitignore t)
 '(safe-local-variable-values
   (quote
    ((company-clang-arguments "-I.")
     (Base . 10)
     (Package . CL-USER)
     (Syntax . COMMON-LISP))))
 '(slime-company-completion (quote fuzzy)))

[8.82]

init.el

File addition: init.el (----------)

[4.131]

;;;; -*- mode: Emacs-Lisp;-*-
(setq default-directory "~/emacs-home/")
(make-directory default-directory t)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-to-load-path '("."))
  (normal-top-level-add-subdirs-to-load-path))
(setq vc-follow-symlinks t)
(require 'package)
(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
			 ("org" . "http://orgmode.org/elpa/")
			 ("melpa" . "https://melpa.org/packages/")
			 ("melpa-stable" . "http://stable.melpa.org/packages/"))
      package-archive-priorities '(("melpa-stable" . 1)
                                   ("gnu" . 0)
                                   ("melpa" . 2)
                                   ("org" . 3)))
(package-initialize)
(when (not (package-installed-p 'use-package))
  (package-refresh-contents)
  (package-install 'use-package))
(require 'use-package)
(use-package evil
  :ensure t
  :config
  (define-key evil-normal-state-map " o" 'slime-selector)
  (define-key evil-insert-state-map (kbd "TAB") 'company-complete)
  (use-package lisp-skeletons
    :ensure t
    :config
    (add-hook 'skeleton-end-hook 'skeleton-make-markers))
  (defun helm-generate-lisp-skeleton ()
    (interactive)
    (let ((skeletons '(("defunction" . skel-defun)
                       ("defmacro" . skel-defmacro)
                       ("defparameter" . skel-defparameter)
                       ("defvar" . skel-defvar))))
      (funcall (helm-comp-read "code template: " skeletons))))
  
  (define-key evil-normal-state-map " g" 'helm-generate-lisp-skeleton)
  (define-key evil-visual-state-map " g" 'helm-generate-lisp-skeleton)
  )
;;;;; INDENTATION SETUP  {{{
(progn
  (setq-default indent-tabs-mode nil
                tab-width 2)
  (defvaralias 'c-basic-offset 'tab-width)
  (defvaralias 'sh-basic-offset 'tab-width)
  (defvaralias 'js2-basic-offset 'tab-width)
  (defvaralias 'sgml-basic-offset 'tab-width)
  (defvaralias 'cperl-indent-level 'tab-width))
;;;;; }}}
;;;;; SLIME SETUP {{{
(progn ;slime isn't loaded via use-package because quicklisp-helper keeps it uptodate
  (load (expand-file-name "~/quicklisp/slime-helper.el"))
  ;; Replace "sbcl" with the path to your implementation
  (setq inferior-lisp-program "~/sbcl/bin/sbcl")
  (defun slime-ecl ()
    (interactive)
    (let ((inferior-lisp-program "ecl"))
      (slime)))
  (defun slime-cmucl ()
    (interactive)
    (let ((inferior-lisp-program "cmucl"))
      (slime)))
  (defun slime-sbcl ()
    (interactive)
    (let ((inferior-lisp-program "sbcl"))
      (slime)))
  (defun slime-ccl ()
    (interactive)
    (let ((inferior-lisp-program "ccl"))
      (slime)))
  (add-hook 'lisp-mode-hook
	    '(lambda ()
	       ;;(define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
	       (unless (string= "*slime-scratch*" (buffer-name))
		 (paredit-mode)
		 (evil-paredit-mode))
	       (rainbow-delimiters-mode))) 
  (setq slime-contribs
	'(slime-fancy
	  slime-company
	  slime-macrostep
	  slime-trace-dialog
	  slime-mdot-fu)))
(use-package slime-company
  :no-require t
  :defer t
  :ensure t)
;;;;; }}}
(use-package company
  :ensure t
  :config
  ;; keybindings
  (progn (define-key company-active-map (kbd "C-c h") 'company-quickhelp-manual-begin)
	 (define-key company-active-map (kbd "SPC") (kbd "RET SPC"))
	 (define-key company-active-map (kbd "(") (kbd "RET SPC ("))
	 (define-key company-active-map (kbd "{") (kbd "RET SPC {"))
	 (define-key company-active-map (kbd "[") (kbd "RET [")))
  (message "backends: %s" company-backends)
  (setq company-backends
	'(company-clang
	  company-bbdb
	  company-nxml
	  company-css
	  company-xcode
	  company-cmake
	  company-capf
	  company-files
	  (company-dabbrev-code
	   company-gtags
	   company-etags
	   company-keywords)
	  company-oddmuse
	  company-dabbrev))
  )
;; NOTE: this must be here...
(slime-setup)
(global-company-mode 1)
(use-package projectile
  :ensure t)
(use-package sbt-mode
  :ensure t
  :pin melpa-stable)
(use-package scala-mode
  :ensure t
  :pin melpa-stable)
(use-package ensime
  :ensure t)
(use-package intero
  :ensure t)
;; (use-package jdee
;;   :ensure t)
(use-package mvn
  :ensure t)
(use-package css-eldoc
  :ensure t)
(use-package ag
  :ensure t)
(use-package evil-vimish-fold
  :ensure t
  :config
  (evil-vimish-fold-mode 1))
(use-package zenburn-theme
  :ensure t)
(use-package zeal-at-point
  :ensure t)
(use-package rainbow-delimiters
  :ensure t)
(use-package tabbar
  :ensure t)
(use-package helm
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package evil-visual-mark-mode
  :ensure t)
(advice-add 'evil-delete-marks :after
	    (lambda (&rest args)
	      (evil-visual-mark-render)))
(use-package evil-nerd-commenter
  :ensure t
  :config
  (evilnc-default-hotkeys t))
(use-package paredit
  :ensure t
  :config
  (defun paredit-wiggle-back ()
    (paredit-forward)
    (paredit-backward))
  (defmacro defparedit-wrapper (name invoked-wrapper)
    `(defun ,name ()
       (interactive)
       (paredit-wiggle-back)
       (,invoked-wrapper)))
  (defparedit-wrapper back-then-wrap paredit-wrap-sexp)
  (defparedit-wrapper back-then-wrap-square paredit-wrap-square)
  (defparedit-wrapper back-then-wrap-curly paredit-wrap-curly)
  (defparedit-wrapper back-then-wrap-angled paredit-wrap-angled)
  (defparedit-wrapper back-then-wrap-doublequote paredit-meta-doublequote)
  (define-key evil-normal-state-map ",W" 'back-then-wrap)
  (define-key evil-normal-state-map ",w]" 'back-then-wrap-square)
  (define-key evil-normal-state-map ",w}" 'back-then-wrap-curly)
  (define-key evil-normal-state-map ",w>" 'back-then-wrap-angled)
  (define-key evil-normal-state-map ",w\"" 'back-then-wrap-doublequote)
  (define-key evil-normal-state-map ",S" 'paredit-splice-sexp)
  (define-key evil-normal-state-map ",A" 'paredit-splice-sexp-killing-backward)
  (define-key evil-normal-state-map ",D" 'paredit-splice-sexp-killing-forward)
  (define-key evil-normal-state-map ",|" 'paredit-split-sexp)
  (define-key evil-normal-state-map ",J" 'paredit-join-sexps)
  (define-key evil-normal-state-map ",<" 'paredit-backward-slurp-sexp)
  (define-key evil-normal-state-map ",," 'paredit-backward-barf-sexp) 
  (define-key evil-normal-state-map ",>" 'paredit-forward-slurp-sexp)
  (define-key evil-normal-state-map ",." 'paredit-forward-barf-sexp) 
  (define-key evil-normal-state-map ",~" 'paredit-convolute-sexp))
(use-package  evil-paredit
  :ensure t)
(use-package evil-numbers
  :ensure t
  :config
  (global-set-key (kbd "C-c +") 'evil-numbers/inc-at-pt)
  (global-set-key (kbd "C-c -") 'evil-numbers/dec-at-pt))
(use-package eldoc-eval
  :ensure t)
(use-package editorconfig
  :ensure t
  :config
  (editorconfig-mode 1))
(use-package csv-mode
  :ensure t)
(use-package color-theme
  :ensure t)
(use-package ansible
  :ensure t)
(use-package alect-themes
  :ensure t)
(use-package ac-js2
  :ensure t)
(use-package yaml-mode
  :ensure t)
(use-package web-mode
  :ensure t)
(use-package vue-mode
  :ensure t)
(use-package typescript-mode
  :ensure t)
(use-package scss-mode
  :ensure t)
(use-package rust-mode
  :ensure t)
(use-package  markdown-mode
  :ensure t)
(use-package magit
  :ensure t)
(use-package highlight-parentheses
  :ensure t)
(use-package helm-projectile
  :ensure t)
(use-package helm-ls-git
  :ensure t)
;;(use-package helm-git
;;  :ensure t)
(use-package helm-css-scss
  :ensure t)
(use-package helm-cider
  :ensure t)
(use-package helm-ag-r
  :ensure t)
(use-package helm-ag
  :ensure t)
(use-package evil-surround
  :ensure t)
(use-package evil-leader
  :ensure t)
(use-package emmet-mode
  :ensure t)
(use-package project-explorer
  :ensure t
  )
(use-package ggtags
  :ensure t
  :config
  (ggtags-mode 1)
  (add-hook 'c-mode-common-hook
	    (lambda ()
	      (when (derived-mode-p 'c-mode 'c++-mode 'java-mode 'asm-mode)
		(ggtags-mode 1)))))
(use-package pollen-mode
  :config
  (defun insert-lozenge ()
    (interactive)
    (insert-char 9674))
  (define-key evil-insert-state-map (kbd "C-c C-l") 'insert-lozenge))
(progn ; helm
  (require 'helm-config)
  (helm-mode)
  (global-set-key (kbd "C-x C-f") 'helm-find-files)
  (define-key evil-normal-state-map " f" 'helm-projectile)
  (define-key evil-normal-state-map " j" 'helm-buffers-list)
  (global-set-key (kbd "M-x") 'helm-M-x))
(require 'js2-mode)
(require 'projectile)
(projectile-mode)
(add-hook 'after-init-hook
	  (lambda ()
	    (unless (server-running-p)
	      (server-start))
	    (evil-mode)
	    (paredit-mode)
	    (evil-paredit-mode)
	    (global-company-mode)
	    (global-linum-mode)))
(progn ; linum
  (setq linum-format "%5d\u2502"))
(require 'evil-numbers)
(define-key evil-normal-state-map "ZZ" 'save-buffer)
(define-key evil-normal-state-map ",zz" 'zeal-at-point)
(modify-syntax-entry ?_ "w" js-mode-syntax-table)
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?[ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?] "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?{ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?} "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" emacs-lisp-mode-syntax-table)
(let ((default-directory  "~/.emacs.d/lisp/"))
  (make-directory default-directory t)
  (normal-top-level-add-subdirs-to-load-path))
(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.
 '(default ((t (:family "Source Code Pro" :foundry "adobe" :slant normal :weight semi-bold :height 113 :width normal)))))
 
(setq erc-hide-list '("JOIN" "PART" "QUIT"))
;; (defun znc-erc ()
;;   (interactive)
;;   (erc-ssl :server "localhost" :port 6697 :nick "edwlan/freenode" :password "t31ch3rtb"))
(add-to-list 'auto-mode-alist '("\\.cljs\\.hl\\'" . clojurescript-mode))
(add-hook 'ruby-mode-hook
	  '(lambda ()
	     (eldoc-mode)
	     (robe-mode)))
(add-hook 'clojure-mode-hook
	  '(lambda ()
	     ;; Hoplon functions and macros
	     (paredit-mode)
	     (define-key evil-insert-state-map "^N" 'helm-cider-apropos)
	     (dolist (pair '((page . 'defun)
			     (loop-tpl . 'defun)
			     (if-tpl . '1)
			     (for-tpl . '1)
			     (case-tpl . '1)
			     (cond-tpl . 'defun)))
	       (put-clojure-indent (car pair)
				   (car (last pair))))))
(setq tls-program '("openssl s_client -connect %h:%p -no_ssl2 -ign_eof"))
(global-auto-revert-mode t)
 ;;; Use auto-complete for ensime
(defun scala/enable-eldoc ()
  "Show error message or type name at point by Eldoc."
  (setq-local eldoc-documentation-function
	      #'(lambda ()
		  (when (ensime-connected-p)
		    (let ((err (ensime-print-errors-at-point)))
		      (or (and err (not (string= err "")) err)
			  (ensime-print-type-at-point))))))
  (eldoc-mode +1))
(defun scala/completing-dot-company ()
  (cond (company-backend
	 (company-complete-selection)
	 (scala/completing-dot))
	(t
	 (insert ".")
	 (company-complete))))
(defun scala/completing-dot-ac ()
  (insert ".")
  (ac-trigger-key-command t))
;; Interactive commands
(defun scala/completing-dot ()
  "Insert a period and show company completions."
  (interactive "*")
  (eval-and-compile (require 'ensime))
  (eval-and-compile (require 's))
  (when (s-matches? (rx (+ (not space)))
		    (buffer-substring (line-beginning-position) (point)))
    (delete-horizontal-space t))
  (cond ((not (and (ensime-connected-p) ensime-completion-style))
	 (insert "."))
	((eq ensime-completion-style 'company)
	 (scala/completing-dot-company))
	((eq ensime-completion-style 'auto-complete)
	 (scala/completing-dot-ac))))
;; Initialization
(add-hook 'ensime-mode-hook #'scala/enable-eldoc)
(add-hook 'scala-mode-hook 'ensime-scala-mode-hook)
(add-hook 'scala-mode-hook 'flycheck-mode)
(add-hook 'haskell-mode-hook 'intero-mode)
(add-hook 'c-mode-common-hook
	  (lambda ()
	    (when (derived-mode-p 'c-mode 'c++-mode 'java-mode)
	      (semantic-mode 1)
	      
	      (global-semanticdb-minor-mode 1)
	      (global-semantic-idle-scheduler-mode 1)
	      (global-semantic-stickyfunc-mode 1)
	      
	      (helm-gtags-mode)
	      (ggtags-mode 1))))
(setq company-backends (delete 'company-semantic company-backends))
(defun alexott/cedet-hook ()
  (local-set-key "\C-c\C-j" 'semantic-ia-fast-jump)
  (local-set-key "\C-c\C-s" 'semantic-ia-show-summary))
(add-hook 'c-mode-common-hook 'alexott/cedet-hook)
(add-hook 'c-mode-hook 'alexott/cedet-hook)
(add-hook 'c++-mode-hook 'alexott/cedet-hook)
(defun set-exec-path-from-shell-PATH ()
  "Set up Emacs' `exec-path' and PATH environment variable to match that used by the user's shell.
 
 This is particularly useful under Mac OSX, where GUI apps are not started from a shell."
  (interactive)
  (let ((path-from-shell (replace-regexp-in-string "[ \t\n]*$" "" (shell-command-to-string "$SHELL --login -i -c 'echo $PATH'"))))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))
(set-exec-path-from-shell-PATH)
(require 'ede)
(global-ede-mode)
(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.
 '(ansi-color-faces-vector
   [default bold shadow italic underline bold bold-italic bold])
 '(ansi-color-names-vector
   ["#212526" "#ff4b4b" "#b4fa70" "#fce94f" "#729fcf" "#e090d7" "#8cc4ff" "#eeeeec"])
 '(browse-url-browser-function (quote browse-url-generic))
 '(browse-url-generic-program "x-www-browser")
 '(company-backends
   (quote
    (company-semantic company-bbdb company-nxml company-css company-xcode company-cmake company-capf company-files
                      (company-dabbrev-code company-gtags company-etags company-keywords)
                      company-oddmuse company-dabbrev)))
 '(custom-enabled-themes (quote (zenburn)))
 '(custom-safe-themes
   (quote
    ("f5512c02e0a6887e987a816918b7a684d558716262ac7ee2dd0437ab913eaec6" "9d91458c4ad7c74cf946bd97ad085c0f6a40c370ac0a1cbeb2e3879f15b40553" "4e753673a37c71b07e3026be75dc6af3efbac5ce335f3707b7d6a110ecb636a3" "4aee8551b53a43a883cb0b7f3255d6859d766b6c5e14bcb01bed572fcbef4328" "ab04c00a7e48ad784b52f34aa6bfa1e80d0c3fcacc50e1189af3651013eb0d58" "a0feb1322de9e26a4d209d1cfa236deaf64662bb604fa513cca6a057ddf0ef64" default)))
 '(erc-modules
   (quote
    (autoaway autojoin button capab-identify completion fill irccontrols list match menu move-to-prompt netsplit networks noncommands readonly ring stamp spelling track)))
 '(erc-truncate-mode t)
 '(evil-leader/leader ",")
 '(evil-visual-mark-mode t)
 '(font-use-system-font t)
 '(ggtags-sort-by-nearness t)
 '(ggtags-update-on-save t)
 '(global-evil-surround-mode t)
 '(global-linum-mode t)
 '(haskell-mode-hook
   (quote
    (capitalized-words-mode haskell-decl-scan-mode haskell-indentation-mode highlight-uses-mode imenu-add-menubar-index interactive-haskell-mode)) t)
 '(helm-ls-git-fuzzy-match t)
 '(jdee-server-dir "~/.emacs.d/jdee-server/")
 '(jira-url "https://atomampd.atlassian.net/rpc/xmlrpc")
 '(line-number-mode nil)
 '(mac-command-modifier nil)
 '(mac-option-modifier (quote meta))
 '(mac-pass-command-to-system t)
 '(nrepl-message-colors
   (quote
    ("#CC9393" "#DFAF8F" "#F0DFAF" "#7F9F7F" "#BFEBBF" "#93E0E3" "#94BFF3" "#DC8CC3")))
 '(package-selected-packages
   (quote
    (deft geiser pollen-mode js2-refactor npm-mode helm-dash aggressive-indent company-tern tern srefactor ac-slime znc helm-ag ag helm-projectile notmuch zenburn-theme zeal-at-point use-package tabbar slime-company rainbow-delimiters projectile mvn jdee intero helm evil-visual-mark-mode evil-vimish-fold evil-paredit evil-numbers ensime eldoc-eval editorconfig color-theme ansible alect-themes ac-js2)))
 '(pe/omit-gitignore t)
 '(safe-local-variable-values
   (quote
    ((company-clang-arguments "-I.")
     (Base . 10)
     (Package . CL-USER)
     (Syntax . COMMON-LISP))))
 '(slime-company-completion (quote fuzzy)))

rename emacs to init.el, add compatibility symlink

Dependencies

In channels

Change contents

File deletion: dependencies, dependencies

File addition: init.el (----------)

Replacement in emacs.d/emacs at line 1 [8.82]

File addition: init.el (----------)