Kasim Emacs Config

(defun kbeg-end(comment)
  (interactive
   (list (read-string "Please enter your comments: ")))
  (insert (format "#---> beginning of: %s --->\n\n" comment))
  (insert (format "#<--- ending of: %s <---\n" comment))
  (previous-line)
  (indent-for-tab-command)
  (previous-line)
  (indent-for-tab-command))

(defun kcreate-non-existent-directory ()
  (let ((parent-directory (file-name-directory buffer-file-name)))
    (when (and (not (file-exists-p parent-directory))
               (y-or-n-p (format "Directory `%s' does not exist! Create it?" parent-directory)))
      (make-directory parent-directory t))))
(add-to-list 'find-file-not-found-functions #'kcreate-non-existent-directory)

(defun kcurrent-font ()
  (interactive)
  (message
   (format "Current font is: %s" (face-attribute 'default :font))))

(defun kload-config ()
  "Reloads my Emacs config."
  (interactive)
  (org-babel-load-file (expand-file-name "~/.emacs.d/config.org")))

(defun ktemp-window-kill-buffer ()
  "Kills temp buffer shown"
  (interactive)
  ;; Window selection is used because point goes to a different window
  ;; if more than 2 windows are present
  (let ((win-curr (selected-window))
        (temp (or (get-buffer-window "*Help*" 0)
                  (get-buffer-window "*grep*" 0)
                  (get-buffer-window "*Completions*" 0)
                  (get-buffer-window "*compilation*" 0)
                  (get-buffer-window "*Occur*" 0))))
    (select-window temp)
    (kill-this-buffer)
    (select-window win-curr)))

(defun kformat-org-src-block ()
  (interactive)
  (when (org-in-src-block-p)
    (org-edit-special)
    (indent-region (point-min) (point-max))
    (org-edit-src-exit)))

(defun ksudo-edit (&optional arg)
  ;; Edit currently visited file as root. With a prefix ARG prompt
  ;; for a file to visit.  Will also prompt for a file to
  ;; visit if current buffer is not visiting a file.
  (interactive "P")
  (if (or arg (not buffer-file-name))
      (find-file (concat "/sudo:root@localhost:"
                         (ido-read-file-name "Find file(as root): ")))
    (find-alternate-file (concat "/sudo:root@localhost:" buffer-file-name))))

(defun kfill-or-unfill ()
  "Like `fill-paragraph', but unfill if used twice."
  (interactive)
  (let ((fill-column
         (if (eq last-command 'kfill-or-unfill)
             (progn (setq this-command nil)
                    (point-max))
           fill-column)))
    (call-interactively #'fill-paragraph)))
(global-set-key [remap fill-paragraph]
                #'kfill-or-unfill)

(defun kdired-open-file ()
  "In Dired, open a file using its default application."
  (interactive)
  (let ((file (dired-get-filename nil t)))
    (unless (file-directory-p file)
      (message "Opening %s..." file)
      (call-process (if (equal system-type 'darwin)
                        "open"
                      "xdg-open") nil 0 nil file))))

(defun kkill-buffers-by-mode (mode)
  (mapc (lambda (buffer)
          (when (eq mode (buffer-local-value 'major-mode buffer))
            (kill-buffer buffer)))
        (buffer-list)))

(defun kkill-dired-buffers ()
  (interactive)
  (kkill-buffers-by-mode 'dired-mode))

(defun kkill-term-buffers ()
  (interactive)
  (kkill-buffers-by-mode 'term-mode))

(defun kdelete-file ()
  (interactive)
  (delete-file buffer-file-name)
  (kill-buffer))

(defun kget-buffer-dir ()
  (if buffer-file-name
      (file-name-directory buffer-file-name)
    nil))

(defun kcopy-to-os-clipboard (str)
  (when str
    (kill-new str)
    str))

(defun kfqn ()
  (interactive)
  (kcopy-to-os-clipboard buffer-file-name))

(defun kdir ()
  (interactive)
  (kcopy-to-os-clipboard (kget-buffer-dir)))

(defun 3coll-view ()
  (interactive)
  (delete-other-windows)
  (save-excursion
    (dotimes (i (1- (/ (/ (frame-pixel-width) (frame-char-width)) 90)))
      (split-window-horizontally 90)
      (other-window 1)
      (bury-buffer))
    (balance-windows)))

(defun 4windows-view ()
  "Splite window into 4 sub-window"
  (interactive)
  (delete-other-windows)
  (progn (split-window-vertically)
         (split-window-horizontally)
         (other-window 2)
         (split-window-horizontally)))

(defun kpdf-view ()
  "For pdf reading"
  (interactive)
  (delete-other-windows)
  (save-excursion
    (pdf-outline)
    (shrink-window-horizontally 40)))

(defun kuntabify-buffer ()
  "Untabify current buffer"
  (interactive)
  (untabify (point-min) (point-max)))

(defun kfocus-window ()
  "Focus current window by deleting windows up or down"
  (interactive)
  (condition-case nil
      (progn
        (windmove-up)
        (delete-window))
    (error
     (windmove-down)
     (delete-window))))

(defun ktoggle-modes (modes flag)
  (dolist (mode modes)
    (when (fboundp mode) (funcall mode flag))))

(defun knotify-compilation-result (buffer msg)
  ;; Notify that the compilation is finished,
  ;; and set the focus back to Emacs frame if failed"
  (if (string-match "^finished" msg)
      (tooltip-show "\n Command Successful :-) \n ")
    (progn (tooltip-show "\n Command Failed :-( \n ")
           (select-frame-set-input-focus current-frame))))

(defun kswap-buffers (arg)
  "Swaps the buffers shown in two windows."
  (interactive "p")
  (let ((selector (if (>= arg 0) 'next-window 'previous-window)))
    (while (/= arg 0)
      (let ((this-win (window-buffer))
            (next-win (window-buffer (funcall selector))))
        (set-window-buffer (selected-window) next-win)
        (set-window-buffer (funcall selector) this-win)
        (select-window (funcall selector)))
      (setq arg (if (plusp arg) (1- arg) (1+ arg))))))

(defun ktoggle-frame-split ()
  ;; If the frame is split vertically, split it horizontally or vice versa.
  ;; Assumes that the frame is only split into two."
  (interactive)
  (unless (= (length (window-list)) 2) (error "Can only toggle a frame split in two"))
  (let ((split-vertically-p (window-combined-p)))
    (delete-window) ; closes current window
    (if split-vertically-p
        (split-window-horizontally)
      (split-window-vertically)) ; gives us a split with the other window twice
    (switch-to-buffer nil)))

(defun ktail-f (file)
  ;; Create a COMINT mode buffer running the `tail -f` command on
  ;; specified FILE. If FILE is a ssh/scp style remote file spec,
  ;; e.g.,
  ;; user@remote.host.com:/path/to/file.txt
  ;; then a ssh connection is opened to remote.host.com, and `tail -f`
  ;; is invoked on the remote server."
  (interactive "Flocal or remote file: ")
  (let ((buf-name (concat "tail-f " file))
        (re "\\(\\w+\\)@\\([^:]+\\):\\(.*\\)"))
    (if (string-match re file)
        (let ((user (match-string 1 file))
              (host (match-string 2 file))
              (file1 (match-string 3 file)))
          (make-comint buf-name "ssh" nil
                       "-l" user
                       host
                       "tail" "-f" file1))
      (make-comint buf-name "tail" nil "-f" (expand-file-name file)))
    (pop-to-buffer (concat "*" buf-name "*"))))

(defun kcopy-region-as-a-line ()
  (interactive)
  (when (region-active-p)
    (let ((s (buffer-substring (region-beginning) (region-end))))
    (kill-new (s-collapse-whitespace
               (replace-regexp-in-string "\n" " " s))))))

(defun ksend-region-nextw ()
  (interactive)
  (when (region-active-p)
    (let ((s (buffer-substring (region-beginning) (region-end))))
      (save-excursion
        (knext-w)
        (insert s)
        (execute-kbd-macro (kbd "<return>"))
        (knext-w)))))

(defun ksave-all ()
  (interactive)
  (save-some-buffers t))
(add-hook 'focus-out-hook 'ksave-all)

(defun krun (cmd)
  (interactive
   (list
    (ivy-completing-read
     "Enter cmd to run (append ##name for buffer name): "
     (kread-lines (getenv "HISTFILE")))))
  (let* ((cmds (split-string cmd " ##"))
         (bname (format "*%s*" (or (second cmds)
                                   "shx"))))
    (shx bname)
    (pop-to-buffer-same-window bname)
    (insert (format "%s\n" cmd))
    (comint-send-input)))

(defun kprev-w ()
  (interactive)
  (other-window -1))

(defun knext-w ()
  (interactive)
  (other-window 1))

(defun kshell ()
  (interactive)
  (let ((dir (ktry-get-project-root))
        (proj (format "*%s*" (kproject-name))))
    (knext-w)
    (if (and dir proj)
        (shx proj dir)
      (shx "*shx*" (kget-buffer-dir)))))

(defun kshell-history (term)
  (interactive
   (list
    (ivy-completing-read
     ""
     (let ((history nil))
       ;; We have to build up a list ourselves from the ring vector.
       (dotimes (index (ring-length comint-input-ring))
         (push (ring-ref comint-input-ring index) history))
       ;; Show them most-recent-first.
       (setq history (nreverse history))))))
  (insert term))

(defun kshell-on-region (cmd)
  (let ((b (if mark-active (min (point) (mark)) (point-min)))
        (e (if mark-active (max (point) (mark)) (point-max))))
    (shell-command-on-region b e cmd (current-buffer) t)))

(defun kshell-process-sentinel (process state)
  ;; show shell status and kill the buffer automatically
  (message "shell: %s" state)
  (if (or
       (string-match "exited abnormally with code.*" state)
       (string-match "finished" state))
      (kill-buffer (current-buffer))))

(add-hook 'comint-exec-hook
          (lambda ()
            (set-process-sentinel (get-buffer-process (current-buffer))
                                  'kshell-process-sentinel)))

(defun kjson ()
  (interactive)
  (kshell-on-region "python -mjson.tool"))

(defun ksetup-term ()
  ;; mode-map
  (setq mouse-drag-copy-region t)
  (setq term-buffer-maximum-size 100000)
  (setq shell-file-name "bash")
  (define-key term-mode-map (kbd "M-x") 'counsel-M-x)
  (define-key term-mode-map (kbd "M-O") 'knext-w)
  (define-key term-mode-map (kbd "M-o") 'ivy-switch-buffer)
  (define-key term-mode-map (kbd "M-i") 'swiper)
  (define-key term-mode-map (kbd "M-I") 'avy-goto-char-timer)
  (define-key term-mode-map (kbd "<f12>") 'kshell)

  ;; raw map
  (define-key term-raw-map (kbd "C-y") 'term-paste)
  (define-key term-raw-map (kbd "C-k")
    (lambda ()
      (interactive)
      (term-send-raw-string "\C-k")
      (kill-line)))
  (define-key term-raw-map (kbd "M-x") 'counsel-M-x)
  (define-key term-raw-map (kbd "M-O") 'knext-w)
  (define-key term-raw-map (kbd "M-o") 'ivy-switch-buffer)
  (define-key term-raw-map (kbd "M-i") 'swiper)
  (define-key term-raw-map (kbd "M-I") 'avy-goto-char-timer)
  (define-key term-raw-map (kbd "<f12>") 'kshell))

(defun kterm ()
  "If the current buffer is:
       1) a running ansi-term named *ansi-term*, rename it.
       2) a stopped ansi-term, kill it and create a new one.
       3) a non ansi-term, go to an already running ansi-term
          or start a new one while killing a defunt one"
  (interactive)
  (require 'term)
  (let ((is-term (string= "term-mode" major-mode))
        (is-running (term-check-proc (buffer-name)))
        (term-cmd "/bin/bash")
        (anon-term (get-buffer "*ansi-term*")))
    (if is-term
        (if is-running
            (if (string= "*ansi-term*" (buffer-name))
                (call-interactively 'rename-buffer)
              (if anon-term
                  (pop-to-buffer "*ansi-term*")
                (ansi-term term-cmd)))
          (kill-buffer (buffer-name))
          (ansi-term term-cmd))
      (if anon-term
          (if (term-check-proc "*ansi-term*")
              (pop-to-buffer "*ansi-term*")
            (kill-buffer "*ansi-term*")
            (ansi-term term-cmd))
        (ansi-term term-cmd)))))
(global-set-key (kbd "C-c t") 'kterm)

(defun khooks ()
  (add-hook 'term-exec-hook 'kterm-exec-hook)
  (add-hook 'term-mode-hook 'ksetup-term)
  (add-hook 'prog-mode-hook
            '(lambda ()
               (smartparens-global-mode)
               (hs-minor-mode))))

(defun vpn ()
  (interactive)
  (kdo-term-run "vpn"
                "~/ktuman@gmail.com/kone/etc/ssh/vpn"))

(defun visit-project-clj ()
  (interactive)
  (find-file (format "%s/%s" (ktry-get-project-root) "project.clj")))

(defun kltest (&optional ns &optional fn)
  (interactive)
  (let* ((test (format "cd %s && %s test"
                       (ktry-get-project-root)
                       (expand-file-name "~/rcfiles/bin/klj.sh")))
         (command (cond
                   ((and ns fn)
                    (format "%s run-ns -n %s/%s" test ns fn))

                   (ns
                    (format "%s run-ns -n %s" test ns))

                   (t
                    (format "%s unit" test)))))
    (compile (s-trim command))))

(defun kdo-term-run (new-buffer-name cmd &rest switches)
  (setq term-ansi-buffer-name new-buffer-name)
  (setq term-ansi-buffer-name (generate-new-buffer-name term-ansi-buffer-name))
  (setq term-ansi-buffer-name (apply 'make-term term-ansi-buffer-name cmd nil switches))
  (set-buffer term-ansi-buffer-name)
  (term-mode)
  (term-char-mode)
  (term-set-escape-char ?\C-c)
  (switch-to-buffer term-ansi-buffer-name))

(defun kread-lines (filePath)
  "Return a list of lines of a file at filePath."
  (with-temp-buffer
    (insert-file-contents filePath)
    (split-string (buffer-string) "\n" t)))

(defun ssh (host)
  (interactive
   (list
    (completing-read
     "Enter remote host: "
     (-keep (lambda (s)
              (when (s-starts-with? "host" s t)
                (second (split-string s " " t))))
            (kread-lines "~/.ssh/config")))))
  (kdo-term-run host "ssh" host))

(defun kterm-exec-hook ()
  (let* ((buff (current-buffer))
         (proc (get-buffer-process buff)))
    (set-process-sentinel
     proc
     `(lambda (process event)
        (if (string= event "finished\n")
            (kill-buffer ,buff))))))

(defun compilation-mode-colorize-buffer ()
  (toggle-read-only)
  (ansi-color-apply-on-region (point-min) (point-max))
  (toggle-read-only))

(defun ksetup-ansi-color ()
  (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
  (add-hook 'comint-mode-hook 'ansi-color-for-comint-mode-on)
  (add-hook 'compilation-filter-hook 'compilation-mode-colorize-buffer)
  (add-hook 'eshell-preoutput-filter-functions 'ansi-color-filter-apply))

(defun kemacs-startup ()
  (server-start)
  (add-to-list 'initial-frame-alist '(fullscreen . maximized))
  (khooks)
  (kshell)
  (keychain-refresh-environment))

(defun ksymbol-after-slash ()
  (first (last (split-string (symbol-name (symbol-at-point)) "/"))))

(defun kgrep (s)
  "git-grep the entire current repo"
  (interactive "sPlease enter grep term: ")
  (grep-find (concat "git --no-pager grep -P -n "
                     (format "'%s'" s)
                     " `git rev-parse --show-toplevel`"))
  (pop-to-buffer "*grep*"))

(defun kref ()
  "git-grep the entire current repo for reference"
  (interactive)
  (kgrep (cond ((string= "clojure-mode" major-mode)
                (format "/%s" (ksymbol-after-slash)))
               ((string= "ruby-mode" major-mode)
                (format ".%s" (ksymbol-after-slash))))))
(global-set-key (kbd "C-.") 'kref)

(defun ktry-get-project-root ()
  (interactive)
  (condition-case nil
      (projectile-project-root)
    (error
     nil)))

(defun kproject-name ()
  (when-let ((root (ktry-get-project-root)))
    (-> (s-split "/" root t)
        last
        first)))

(defun klisp-buffer-p ()
  (interactive)
  (or (string= "clojure-mode" major-mode)
      (string= "emacs-lisp-mode" major-mode)))

(defun kafter-save ()
  (executable-make-buffer-file-executable-if-script-p)
  (when (klisp-buffer-p)
    (condition-case err
        (progn
          (check-parens)))))
(add-hook 'after-save-hook 'kafter-save)

(defun kbefore-save ()
  (when (klisp-buffer-p)
    (whitespace-cleanup)))
(add-hook 'before-save-hook 'kbefore-save)

(defun pop-kill-ring ()
  (when kill-ring
    (setq kill-ring (cdr kill-ring)))
  (when kill-ring-yank-pointer
    (setq kill-ring-yank-pointer kill-ring)))

(defun dwim-term (&optional p prompt)
  (if p
      (or (kcopy-region-as-a-line) (symbol-at-point))
    (read-string prompt)))

(defun dwim-term-r (&optional p prompt)
  (if p
      (read-string prompt)
    (or (kcopy-region-as-a-line) (symbol-at-point))))

(defun kterm-toggle-mode ()
  "Toggles term between line mode and char mode"
  (interactive)
  (if (term-in-line-mode)
      (term-char-mode)
    (term-line-mode)))

(defun just-one-space-in-region (beg end)
  "replace all whitespace in the region with single spaces"
  (interactive "r")
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (while (re-search-forward "\\s-+" nil t)
        (replace-match " ")))))

(defun kcomint-format-output ()
  "Copy all output from interpreter since last input."
  (interactive)
  (with-current-buffer inferior-clojure-buffer
    (let ((proc (get-buffer-process inferior-clojure-buffer)))
      (save-excursion
        (let ((pmark (progn (goto-char (process-mark proc))
                            (forward-line 0)
                            (point-marker))))
          (->> (buffer-substring comint-last-input-end pmark)
               s-chomp
               (s-chop-suffix "nil")
               s-chomp
               (s-split "#_=>")
               last
               first
               s-trim-left))))))

(defun kmessage-error (str)
  (let ((last-line (->> (s-split "\n" str)
                        last
                        first
                        (s-truncate (- (frame-width) 3)))))
    (when (or (s-contains-p "FAIL" str)
              (s-contains-p "Exception" str)
              (s-contains-p "Error" str))
      (message "%s" (propertize last-line
                                'face '(:foreground "red"))))
    (when (and (s-contains-p ":fail 0" str)
               (s-contains-p ":error 0" str))
      (message "%s" (propertize last-line
                                'face '(:background "green"))))))

(defun kgoto-test-file ()
  (interactive)
  (when (and (string= "clojure-mode" major-mode)
             (not (string-suffix-p "_test.clj" (buffer-file-name))))

    (let ((test-file (->> (s-replace "/src/" "/test/" (buffer-file-name))
                          (s-replace ".clj"  "_test.clj"))))
      (when (file-exists-p test-file)
        (find-file-other-window test-file)))))

(defun kgoto-src-file ()
  (interactive)
  (when (and (string= "clojure-mode" major-mode)
             (not (s-contains-p "/src/" (buffer-file-name))))
    (let ((src-file (s-replace "/test/" "/src/" (buffer-file-name))))
      (find-file-other-window (s-replace "_test.clj" ".clj" src-file)))))

(el-get-bundle s)
(el-get-bundle f)
(el-get-bundle pos-tip)

;; configs
(setq ido-enable-flex-matching t
      ido-everywhere t
      ;; ido-use-filename-at-point 'guess
      ido-use-filename-at-point nil
      ido-create-new-buffer 'always
      ido-ignore-extensions t
      ido-ignore-directories nil
      ido-enable-dot-prefix t
      ido-case-fold t
      ido-auto-merge-work-directories-length -1)
;; enable ido globally
(ido-mode 1)

(defun make-my-shell-output-read-only (text)
  "Add to comint-output-filter-functions to make stdout read only in my shells."
  (let ((inhibit-read-only t)
        (output-end (process-mark (get-buffer-process (current-buffer)))))
    (put-text-property comint-last-output-start output-end 'read-only t)))

(setq tramp-default-method "ssh"          ; uses ControlMaster
      comint-scroll-to-bottom-on-input t  ; always insert at the bottom
      comint-scroll-to-bottom-on-output nil ; always add output at the bottom
      comint-scroll-show-maximum-output t ; scroll to show max possible output
      comint-completion-autolist t        ; show completion list when ambiguous
      comint-input-ignoredups t           ; no duplicates in command history
      comint-buffer-maximum-size 20000    ; max length of the buffer in lines
      comint-get-old-input (lambda () "") ; what to run when i press enter on a
                                        ; line above the current prompt
      comint-input-ring-size 5000         ; max shell history size
      )
(setenv "PAGER" "cat")

(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
(add-hook 'shell-mode-hook (lambda ()
                             (define-key shell-mode-map (kbd "<delete>")
                               'comint-clear-buffer)))
(add-to-list 'comint-output-filter-functions 'shell-strip-ctrl-m)
(add-to-list 'comint-output-filter-functions 'comint-truncate-buffer)
(add-hook 'comint-output-filter-functions 'make-my-shell-output-read-only)

(progn
  (require 'dired-x)
  (set-default 'dired-omit-mode t)
  (setq dired-listing-switches "-alh")
  (setq dired-omit-files (concat dired-omit-files "\\|^\\..+$"))
  (define-key dired-mode-map (kbd "k") 'dired-kill-subdir)
  (define-key dired-mode-map (kbd ">") 'dired-omit-mode)
  (define-key dired-mode-map (kbd "<C-return>") 'kdired-open-file)
  (define-key dired-mode-map (kbd "C-x C-j") 'dired-jump)
  (set-default 'dired-omit-mode t)
  (setq dired-listing-switches "-alh")
  (setq dired-omit-files (concat dired-omit-files "\\|^\\..+$")))

(progn
  (require 'ibuffer)
  (global-set-key (kbd "C-c b") 'ibuffer)
  (setq ibuffer-show-empty-filter-groups nil)
  (setq ibuffer-expert t)
  (setq ibuffer-formats
      '((mark modified read-only " "
              (name 50 50 :left :elide) ; change: 30s were originally 18s
              " "
              (size 9 -1 :right)
              " "
              (mode 16 16 :left :elide)
              " " filename-and-process)
        (mark " "
              (name 16 -1)
              " " filename)))
  (add-hook 'ibuffer-hook
            (lambda ()
              (ibuffer-auto-mode 1)
              (unless (eq ibuffer-sorting-mode 'alphabetic)
                (ibuffer-do-sort-by-alphabetic)))))

(progn
  (require 'ansi-color)
  (ksetup-ansi-color))

(progn
  (require 'compile)
  (add-to-list 'compilation-finish-functions 'knotify-compilation-result)
  (setq compilation-skip-threshold 2) ;; skip anyting less important than error
  (setq compilation-error-regexp-alist
        (append (list '("^FAIL in (.*) (\\([^:]*\\):\\([0-9]+\\)" 1 2) ;; clojure
                      '("^ERROR in(.*) (\\([^:]*\\):\\([0-9]+\\)" 1 2) ;; clojure
                      '("^\\s-*\\[[^]]*\\]\\s-*\\(.+\\):\\([0-9]+\\):" 1 2)) ;; javac
                compilation-error-regexp-alist)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; my web related configs here ;;;;;;;;;;;;;;;;;;;;;;
;;set default browser to chromium
(setq browse-url-browser-function
      (if (equal system-type 'darwin)
          'browse-url-default-macosx-browser
        'browse-url-chromium))

;;quick access hacker news
(defun hn ()
  (interactive)
  (browse-url "http://news.ycombinator.com"))

(defun lobster ()
  (interactive)
  (browse-url "http://lobste.rs"))

(defun search-site-for-term (site-url term)
  (browse-url (format site-url term)))

(defun wikipedia (&optional p)
  (interactive "P")
  (search-site-for-term "http://en.m.wikipedia.org/w/index.php?search=%s"
                        (dwim-term p "Wikipedia: ")))

(defun stackoverflow (&optional p)
  (interactive "P")
  (search-site-for-term "http://stackoverflow.com/search?q=%s"
                        (dwim-term p "StackOverflow: ")))

(defun google (&optional p)
  (interactive "P")
  (search-site-for-term "http://google.com/search?q=%s"
                        (dwim-term p "Google: ")))

(defun kurl (&optional p)
  (interactive "P")
  (browse-url (dwim-term p "URL: ")))

(progn
  (require 'ediff)
  (setq ediff-window-setup-function 'ediff-setup-windows-plain)
  (setq ediff-split-window-function 'split-window-horizontally)
  (add-hook 'ediff-after-quit-hook-internal 'winner-undo))

(setq org-ellipsis " ")
(setq org-src-fontify-natively t)
(setq org-src-tab-acts-natively t)
(setq org-confirm-babel-evaluate nil)
(setq org-export-with-smart-quotes t)
(setq org-src-window-setup 'current-window)

(el-get-bundle htmlize)

(add-hook 'org-mode-hook
          '(lambda ()
             (visual-line-mode 1)))

(global-set-key (kbd "C-c '") 'org-edit-src-code)

(el-get-bundle org-bullets
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode))))

(add-to-list 'org-structure-template-alist
             '("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC"))

(add-to-list 'org-structure-template-alist
               '("clj" "#+BEGIN_SRC clojure\n?\n#+END_SRC"))
(add-to-list 'org-structure-template-alist
               '("sh" "#+BEGIN_SRC shell\n?\n#+END_SRC"))

(global-set-key (kbd "C-c c") 'org-capture)
(global-set-key (kbd "C-c a") 'org-agenda)

(defun karchive-when-done ()
  "Archive current entry if it is marked as DONE (see `org-done-keywords')."
  (interactive)
  (when (org-entry-is-done-p)
    (org-archive-subtree-default)))

(add-hook 'org-after-todo-state-change-hook
    'karchive-when-done)

(setq org-agenda-files '("~/gdrive/gtd/inbox.org"
                         "~/gdrive/gtd/gtd.org"
                         "~/gdrive/gtd/tickler.org"))

(setq org-capture-templates '(("t" "Todo [inbox]" entry
                               (file+headline "~/gdrive/gtd/inbox.org" "Tasks")
                               "* TODO %i%?")
                              ("T" "Tickler" entry
                               (file+headline "~/gdrive/gtd/tickler.org" "Tickler")
                               "* %i%? \n %U")))

(setq org-refile-targets '(("~/gdrive/gtd/gtd.org" :maxlevel . 3)
                           ("~/gdrive/gtd/someday.org" :level . 1)
                           ("~/gdrive/gtd/tickler.org" :maxlevel . 2)))

(setq org-todo-keywords
      '((sequence "TODO(t)" "WAITING(w)" "|" "DONE(d)" "CANCELLED(c)")))

(require 'ob-clojure)
(org-babel-do-load-languages
 'org-babel-load-languages
 '(
   (shell . t)
   ;; Include other languages here...
   ))

(el-get-bundle exec-path-from-shell
  (progn
    (setq exec-path-from-shell-check-startup-files nil)
    (exec-path-from-shell-copy-env "HISTFILE")
    (exec-path-from-shell-initialize)))

(el-get-bundle bash-completion
  (progn
    (require 'bash-completion)
    (bash-completion-setup)
    (add-hook 'shell-mode-hook
              (lambda ()
                (company-mode -1)))))

(el-get-bundle shx
  (progn
    (require 'shx)
    (add-hook 'shell-mode-hook
              (lambda ()
                (setq comint-input-ring-file-name
                      (getenv "HISTFILE"))
                (comint-read-input-ring 'silent)))
    (define-key shell-mode-map (kbd "C-r") 'kshell-history)
    (global-set-key (kbd "<f12>") 'kshell)))

(el-get-bundle keychain-environment)

(el-get-bundle transient)
(el-get-bundle magit)

(el-get-bundle git-timemachine)

(el-get-bundle git-link)

(el-get-bundle sesman)
(el-get-bundle clojure-mode
  (progn
    (require 'clojure-mode)
    (define-clojure-indent
      (defsc :defn)
      (specification :defn)
      (behavior :defn)
      (provided :defn)
      (assertions :defn)
      (:require :defn)
      (:use :defn)
      (:import :defn)
      (html :defn)
      (div :defn)
      (action :defn))))


(defun mycider-setup ()
  (progn
    (require 'cider)
    (require 'cider-mode)
    (setq org-babel-clojure-backend 'cider)
    (setq cider-font-lock-dynamically nil)
    (setq cider-repl-history-file "~/.cider-repl-history")
    (add-hook 'cider-mode-hook #'eldoc-mode)
    (add-hook 'cider-mode-hook #'imenu-add-menubar-index)
    (add-hook 'cider-mode-hook '(lambda ()
                                  (local-set-key (kbd "RET") 'newline-and-indent)))
    (add-hook 'cider-repl-mode-hook #'company-mode)
    (add-hook 'cider-mode-hook #'company-mode)
    (define-key cider-repl-mode-map (kbd "C-r")
      '(lambda (term)
         (interactive (list
                       (ivy-completing-read
                        ""
                        cider-repl-input-history)))
         (insert term)))))


(if (or (string= "birkey" (system-name))
        (string= "birkeyz" (system-name))
        (string= "ak-mbp" (system-name)))
    (el-get-bundle cider
      (mycider-setup))
  (el-get-bundle cider
    :checkout "v0.18.0"
    (mycider-setup)))

(el-get-bundle format-all
  (add-hook 'clojure-mode-hook 'format-all-mode))

(el-get-bundle alchemist
  (progn
    (require 'alchemist)
    (setq alchemist-hooks-compile-on-save t)
    (add-hook 'elixir-mode-hook
              (lambda () (add-hook 'before-save-hook 'elixir-format nil t)))))

(el-get-bundle robe
  (progn
    ;; This is needed so the rails console command is `rails c`
    (defun inf-ruby-console-rails (dir)
      "Run Rails console in DIR."
      (interactive (list (inf-ruby-console-read-directory 'rails)))
      (let* ((default-directory (file-name-as-directory dir))
             (env (inf-ruby-console-rails-env))
             (with-bundler (file-exists-p "Gemfile")))
        (inf-ruby-console-run
         (concat (when with-bundler "bundle exec ")
                 "rails c "
                 env)
         "rails")))
    (add-hook 'ruby-mode-hook 'robe-mode)))

(el-get-bundle crystal-mode)