Emagician-Base

Resulting in this abomination:

(setq gc-cons-threshold (* 500 1024 1024))

There was even a little voice in my head that said "Maybe Jonnay, maybe you shouldn't fuck with the garbage collector?"

Which gave me these lessons:

• Listen to that little voice, and
• don't fuck around with garbage collection unless you know what you're doing and what you're setting.

One thing you can do is to set Garbage Collection to a high value during startup or execution of commands, and then set it back down to a reasonable value afterwards. That doesn't change the timing of garbage collection only forstalls it for one big stoppa-tha-world.

Another option is to handle the setting of the GC value after a period of idle time. This would be great for startup, but kinda horrible for command execution.

http://bling.github.io/blog/2016/01/18/why-are-you-changing-gc-cons-threshold/

(defvar lou-the-gc-max (* 512 1024 1024)
  "Maximum Size of garbage collector.  Half gig seems reasonable.
This value is basically not sane.")

(defvar lou-the-gc-sane (car (get 'gc-cons-threshold 'standard-value))
  "Sane GC Value, straight from The Yaks Mouth.")

(defvar lou-is-chatty t
  "Whether or not Lou is chatty about debug messages")

(defun lou-the-gc-go-crazy ()
  "Tell Lou the garbage collector to use maximum garbage size"
  (when lou-is-chatty
    (with-current-buffer (messages-buffer)
      (let ((inhibit-read-only t))
        (goto-char (point-max))
        (insert "\nLou is going crazy!"))))
  (setq gc-cons-threshold lou-the-gc-max))

(defun lou-the-gc-be-sane ()
  "Tell Lou to stop acting crazy and use a sane garbage collection ammount"
  (when lou-is-chatty
    (with-current-buffer (messages-buffer)
      (let ((inhibit-read-only t))
        (goto-char (point-max))
        (insert "\nLou is sane again."))))

  (setq gc-cons-threshold lou-the-gc-sane))

(unless after-init-time
  (lou-the-gc-go-crazy)
  (add-hook 'emacs-startup-hook #'lou-the-gc-be-sane t))

(add-hook 'minibuffer-setup-hook #'lou-the-gc-go-crazy)
(add-hook 'minibuffer-exit-hook #'lou-the-gc-be-sane)

(setq load-prefer-newer t)

(defmacro lexically (&rest forms)
  "Lexically execute forms"
  `(eval '(progn ,@forms) t))

(ert-deftest lexially () 
  (should (equal (macroexpand '(lexically t t t)) '(eval (quote (progn t t t)) t)))) 

Sometimes the depricated CL environment is still required. One day this can go away. That day isn't today.

(require 'cl)

(setq eval-expression-print-length 9000
      print-length 90000
      eval-expression-print-level 20
      print-level 900)

(use-package anaphora)

Run commands asyncronously.

(use-package async)

ERT for testing. Of course.

El-mock is too damn rubylike.

Fakir is cool ass, but I don't need it. yet. Also, a great name

(use-package noflet)

(use-package memory-usage)

(defun emagician/meta/run-all-emagick-tests ()
  "Run all tests for emagick-🐰" 
  (interactive)
  (ert-run-tests-interactively "emagick"))

(defun emagick-🐰/alist-set (key value alist &optional use-proper-list)
  "Sets or adds KEY with VALUE on ALIST, and return the list.
If USE-PROPER-LIST is true then instead of a (dotted . list) a
(proper list) is constructed insted."
  (let ((list-frag (funcall (if use-proper-list #'list #'cons)
                            key
                            value)))
    (if (not (null alist))
        (cons list-frag
              (assq-delete-all key alist))
      (list list-frag))))

(ert-deftest emagick-🐰/alist-set-on-empty-list ()
  ""
  (should (equal (emagick-🐰/alist-set 'foo 'bar '())
                 '((foo . bar))))
  (should (equal (emagick-🐰/alist-set 'foo 'bar '() t)
                 '((foo bar)))))

(ert-deftest emagick-🐰/alist-set-on-list-with-element ()
  ""
  (should (equal (emagick-🐰/alist-set 'baz 'blarg '((foo . bar)))
                 '((baz . blarg)(foo . bar))))
  (should (equal (emagick-🐰/alist-set 'baz 'blarg '((foo bar)) t)
                 '((baz blarg)(foo bar)))))

(ert-deftest emagick-🐰/alist-set-on-list-without-element ()
  ""
  (should (equal (emagick-🐰/alist-set 'foo 'bar '((foo . baz)))
                 '((foo . bar))))
  (should (equal (emagick-🐰/alist-set 'foo 'bar '((foo baz)) t)
                 '((foo bar)))))

HOLY SHIT. This worked better than I expected.

This function snarfs the backtrace when called and returns it as a list. This is used primarily for initialization testing.

(load-file-name or buffer-file-name)

(defun emagician/snarf-backtrace ()
  "Snarfs the backtrace as a list"
  (let ((num 3)
        (frames (cons (backtrace-frame 3) nil)))
    (while (car frames)
      (when (> num 50) (error "Too many frames %S" (pp frames)))
      (setq num (1+ num))
      (setq frames (cons (backtrace-frame (+ 3 num)) frames)))
    (cdr frames)))

(ert-deftest emagician/snarf-backtrace ()
  (should (equal '(t emagician/snarf-backtrace) (car (last (emagician/snarf-backtrace))))))

A bit of a naive version of this for now.

(defun emagician/sanitize-file-name (str)
  (replace-regexp-in-string "[/~\000]" "-" str))

(ert-deftest emagician/sanitize-file-name ()
  (should (equal "" (emagician/sanitize-file-name "")))
  (should (equal "foo" (emagician/sanitize-file-name "foo")))
  (should (equal "-foo" (emagician/sanitize-file-name "/foo")))
  (should (equal "-foo" (emagician/sanitize-file-name "~foo"))))

Make sure a dirs exist.

(defun emagician/expect-dir (dir &optional pathroot) 
  "Ensures that the named directory exists."
  (let ((path (expand-file-name dir
                                (or pathroot emagician/dir))))
    (when (not (file-directory-p path))
      (when (file-exists-p path)
        (error "Cannot Create %s, it already exists and is a file." path))
      (make-directory path nil))
    path))

(ert-deftest emagician/expect-dir ()
  (let ((tdir "emagician-expect-dir-scratch-monkey"))   
    (should (not (file-directory-p tdir)))
    (should (file-directory-p (emagician/expect-dir "emagician-expect-dir-dummy-test-dir")))
    (should (file-directory-p (emagician/expect-dir "emagician-expect-dir-dummy-test-dir")))
    (should (progn (delete-directory tdir) (not (file-directory-p tdir))))
    (should-error (emagician/expect-dir "foo/bar/baz/notexisting")))
  (should-error (emagician/expect-dir "Emagician.org")))

(ert-deftest emagician/expect-dir-with-extra-arg ()
  (let* ((dirname "emagician-expect-dir-scratch-monkey")
         (tdir (concat temporary-file-directory dirname)))
    (should (not (file-directory-p tdir)))
    (should (file-directory-p (emagician/expect-dir dirname
                                                    temporary-file-directory)))
    (should (progn (delete-directory tdir)
                   (not (file-directory-p tdir))))))

  (defun emagician/add-to-path (path &rest front)
    "Adds PATH to the PATH env variable, eshell-path-env as well as exec-path.
If FRONT is non nil, then PATH will be prepended to the env and shell vars.  
The exec-path always will always have it prepended. "
    (let ((shell-path (concat 
                       (if front 
                           path
                         (getenv "PATH"))
                       ":"
                       (if front
                           (getenv "PATH")
                         path))))
      (setenv "PATH" shell-path)
      (setq eshell-path-env shell-path)
      (setq exec-path (cons path exec-path))))

When the starter kit is loaded we want to display the scratch buffer with a new and improved scratch buffer giving some statistics, showing inspirational messages, dire warnings, and apocalyptic screeds.

We also show a set of quick elisp commands that can be immediately run by moving the point to the relevant line of elisp, and executing.

This exemplifies everything that is good with Emacs.

If you want to add items, you can do so through the emagician/scratch-links variable.

(defvar emagician/scratch-links `((magit-status ,emagician/dir))
  "A list of elisp that is inserted in the scratch buffer at startup.")