fiddlerwoaroof/dotfiles - Change Z3ALV46TWXGAUOXZXRFE6RCH66NCJ7GVNS43TYWXWN24TA5JVHCQC

chore: cider configuration gets its own file

Created by Ed Langley on December 7, 2019

Z3ALV46TWXGAUOXZXRFE6RCH66NCJ7GVNS43TYWXWN24TA5JVHCQC

Dependencies

In channels

main

Change contents

File deletion: dependencies, dependencies
BFD:BFD[3.1] → [4.129:152]
BFD:BFD[3.1] → [4.129:152]
BFD:BFD[4.152] → [4.128:128]

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

[5.4163]

(defun fwoar/cider-hook-base ()
  (flycheck-mode)
  (rainbow-delimiters-mode 1)
  (evil-smartparens-mode 1)
  (smartparens-strict-mode 1)
  (helm-cider-mode 1)
  (cider-company-enable-fuzzy-completion))
(defun fwoar/cider-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 1))
(defun fwoar/cider-repl-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 0))
(defun fwoar/cider-eval-expression-at-point-in-repl ()
  (interactive)
  (let ((form (cider-defun-at-point)))
    ;; Strip excess whitespace
    (while (string-match "\\`\s+\\|\n+\\'" form)
      (setq form (replace-match "" t t form)))
    (with-current-buffer (cider-current-repl nil t)
      (let ((fw/window (get-buffer-window)))
        (with-selected-window fw/window
          (end-of-buffer)
          (insert form)
          (cider-repl-return)
          (end-of-buffer))))))
(use-package cider
  :ensure t
  :config
  (require 'cider-selector)
  (define-key evil-normal-state-map " t" 'cider-test-run-ns-tests)
  (evil-define-key 'normal clojure-mode-map " '" 'helm-cider-apropos)
  (def-cider-selector-method ?S "find clojure project file"
    (fwoar--find-system))
  (add-hook 'cider-mode-hook 'fwoar/cider-hook)
  (add-hook 'cider-repl-mode-hook 'fwoar/cider-repl-hook)
  (modify-syntax-entry ?: "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?_ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?~ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?. "w" clojure-mode-syntax-table)
  (define-key cider-repl-mode-map (kbd "C-c M-o") 'cider-repl-clear-buffer)
  (define-key cider-repl-mode-map (kbd "C-c C-o") 'cider-repl-clear-output)
  (setq cider-save-file-on-load t
        cider-repl-history-file "~/.emacs.d/cider-history.clj")
  (define-key cider-mode-map
    (kbd "C-c C-j") 'fwoar/cider-eval-expression-at-point-in-repl))
(use-package flycheck-clj-kondo
  :ensure t)

File addition: cider-conf.el (----------)

[5.4163]

(defun fwoar/cider-hook-base ()
  (flycheck-mode)
  (rainbow-delimiters-mode 1)
  (evil-smartparens-mode 1)
  (smartparens-strict-mode 1)
  (helm-cider-mode 1)
  (cider-company-enable-fuzzy-completion))
(defun fwoar/cider-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 1))
(defun fwoar/cider-repl-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 0))
(defun fwoar/cider-eval-expression-at-point-in-repl ()
  (interactive)
  (let ((form (cider-defun-at-point)))
    ;; Strip excess whitespace
    (while (string-match "\\`\s+\\|\n+\\'" form)
      (setq form (replace-match "" t t form)))
    (with-current-buffer (cider-current-repl nil t)
      (let ((fw/window (get-buffer-window)))
        (with-selected-window fw/window
          (end-of-buffer)
          (insert form)
          (cider-repl-return)
          (end-of-buffer))))))
(use-package cider
  :ensure t
  :config
  (require 'cider-selector)
  (define-key evil-normal-state-map " t" 'cider-test-run-ns-tests)
  (evil-define-key 'normal clojure-mode-map " '" 'helm-cider-apropos)
  (def-cider-selector-method ?S "find clojure project file"
    (fwoar--find-system))
  (add-hook 'cider-mode-hook 'fwoar/cider-hook)
  (add-hook 'cider-repl-mode-hook 'fwoar/cider-repl-hook)
  (modify-syntax-entry ?: "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?_ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?~ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?. "w" clojure-mode-syntax-table)
  (define-key cider-repl-mode-map (kbd "C-c M-o") 'cider-repl-clear-buffer)
  (define-key cider-repl-mode-map (kbd "C-c C-o") 'cider-repl-clear-output)
  (setq cider-save-file-on-load t
        cider-repl-history-file "~/.emacs.d/cider-history.clj")
  (define-key cider-mode-map
    (kbd "C-c C-j") 'fwoar/cider-eval-expression-at-point-in-repl))
(use-package clj-refactor
  :after cider
  :ensure t
  :config
  (evil-define-key 'normal clojure-mode-map (kbd "SPC r") 'hydra-cljr-toplevel-form-menu/body))
(use-package helm-cider
  :after cider helm
  :ensure t)
(use-package flycheck-clj-kondo
  :after flycheck
  :ensure t)
(defun find-clojure-project-file ()
  (let ((systems (directory-files
                  (locate-dominating-file default-directory
                                          (lambda (n)
                                            (or (directory-files n nil "project.clj")
                                                (directory-files n nil "build.boot")
                                                (directory-files n nil "deps.edn")
                                                (directory-files n nil "shadow-cljs.edn"))))
                  t "^\\(project.clj\\|build.boot\\|deps.edn\\|shadow-cljs.edn\\)$")))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
(cl-defmethod fwoar--find-system (&context (major-mode (derived-mode clojure-mode)))
  (find-clojure-project-file))
(cl-defmethod fwoar--find-system (&context (major-mode (derived-mode cider-repl-mode)))
  (find-clojure-project-file))
(defmethod fwoar--pl-selector (&context (major-mode clojure-mode))
  (cider-selector))
(defmethod fwoar--pl-selector (&context (projectile-project-type (eql :clojure)))
  (cider-selector))
(defmethod fwoar--pl-selector (&context (major-mode cider-repl-mode))
  (cider-selector))

Deletion in emacs.d/init.el at line 313 [7.136]

B:BD[6.2983] → [6.2983:3770]

B:BD[6.3853] → [6.3853:3854]

(cl-defmethod fwoar--find-system (&context (major-mode clojure-mode))
  (let ((systems (directory-files
                  (locate-dominating-file default-directory
                                          (lambda (n)
                                            (or (directory-files n nil "project.clj")
                                                (directory-files n nil "build.boot")
                                                (directory-files n nil "deps.edn")
                                                (directory-files n nil "shadow-cljs.edn"))))
                  t "^\\(project.clj\\|build.boot\\|deps.edn\\|shadow-cljs.edn\\)$")))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))

Replacement in emacs.d/init.el at line 314 [7.136]

B:BD[8.1430] → [8.1430:1473]

  (:method ()
           (slime-selector))

[8.1430]

[9.636]

  (:method () (slime-selector)))
(cl-defgeneric fwoar--find-system ())

Deletion in emacs.d/init.el at line 317 [7.136]

∅:D[9.637] → [8.1473:1521]

B:BD[8.1473] → [8.1473:1521]

B:BD[8.1521] → [10.168:340]

∅:D[10.340] → [8.1521:1551]

B:BD[8.1521] → [8.1521:1551]

B:BD[8.1551] → [9.638:639]

  (:method (&context (major-mode clojure-mode))
           (cider-selector))
  (:method (&context (projectile-project-type (eql :clojure)))
           (cider-selector))
  (:method (&context (major-mode cider-repl-mode))
           (cider-selector)))

Insertion in emacs.d/init.el at line 322 [7.136]
[8.1680]
[11.179]
```
(load-package-configuration 'cider)
```

Deletion in emacs.d/init.el at line 324 [7.136]

B:BD[7.4266] → [12.5879:5898]

B:BD[12.5898] → [9.640:652]

∅:D[9.652] → [12.5898:5908]

B:BD[12.5898] → [12.5898:5908]

B:BD[12.5908] → [13.170:198]

∅:D[13.198] → [12.5908:5975]

B:BD[12.5908] → [12.5908:5975]

B:BD[12.5975] → [14.3373:3443]

B:BD[14.3578] → [15.18425:18426]

B:BD[15.18426] → [13.199:286]

∅:D[13.286] → [14.3578:3630]

∅:D[15.18426] → [14.3578:3630]

B:BD[14.3578] → [14.3578:3630]

B:BD[14.3630] → [9.653:683]

∅:D[9.683] → [15.18427:18864]

B:BD[14.3630] → [15.18427:18864]

B:BD[15.18864] → [16.172:213]

∅:D[16.213] → [15.18905:18995]

B:BD[15.18905] → [15.18905:18995]

∅:D[14.3812] → [12.6123:6352]

∅:D[15.18995] → [12.6123:6352]

B:BD[12.6123] → [12.6123:6352]

B:BD[12.6352] → [17.168:321]

∅:D[17.321] → [18.9391:9489]

B:BD[12.6352] → [18.9391:9489]

B:BD[18.9489] → [9.684:1281]

∅:D[9.1281] → [15.19031:19473]

∅:D[18.9489] → [15.19031:19473]

B:BD[15.19031] → [15.19031:19473]

B:BD[15.19473] → [9.1282:1283]

∅:D[9.1283] → [12.6352:6356]

∅:D[15.19473] → [12.6352:6356]

B:BD[12.6352] → [12.6352:6356]

B:BD[12.6356] → [9.1284:1330]

∅:D[9.1330] → [11.182:183]

B:BD[12.6356] → [11.182:183]

B:BD[11.183] → [9.1331:1332]

∅:D[9.1332] → [11.183:185]

B:BD[11.183] → [11.183:185]

(use-package cider
  :ensure t
  :config
  (require 'cider-selector)
  (define-key evil-normal-state-map " t" 'cider-test-run-ns-tests)
  (evil-define-key 'normal clojure-mode-map " '" 'helm-cider-apropos)
  (def-cider-selector-method ?S "find clojure project file"
    (fwoar--find-system))
  (add-hook 'cider-mode-hook
            (lambda ()
              (flycheck-mode)
              (rainbow-delimiters-mode 1)
              (evil-smartparens-mode 1)
              (smartparens-strict-mode 1)
              (aggressive-indent-mode 1)
              (helm-cider-mode 1)
              (cider-company-enable-fuzzy-completion)))
  (add-hook 'cider-repl-mode-hook
            (lambda ()
              (rainbow-delimiters-mode 1)
              (evil-smartparens-mode 1)
              (smartparens-strict-mode 1)
              (aggressive-indent-mode 0)
              (helm-cider-mode 1)
              (cider-company-enable-fuzzy-completion)))
  (modify-syntax-entry ?_ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?~ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?. "w" clojure-mode-syntax-table)
  (define-key cider-repl-mode-map (kbd "C-c M-o") 'cider-repl-clear-buffer)
  (define-key cider-repl-mode-map (kbd "C-c C-o") 'cider-repl-clear-output)
  (setq cider-save-file-on-load t
        cider-repl-history-file "~/.emacs.d/cider-history.clj")
  (defun cider-eval-expression-at-point-in-repl ()
    (interactive)
    (let ((form (cider-defun-at-point)))
      ;; Strip excess whitespace
      (while (string-match "\\`\s+\\|\n+\\'" form)
        (setq form (replace-match "" t t form)))
      (with-current-buffer (cider-current-repl nil t)
        (let ((fw/window (get-buffer-window)))
          (with-selected-window fw/window
            (end-of-buffer)
            (insert form)
            (cider-repl-return)
            (end-of-buffer))))))
  (define-key cider-mode-map
    (kbd "C-c C-j") 'cider-eval-expression-at-point-in-repl)
  ;; https://github.com/clojure-emacs/cider/issues/2435
  (defun cider--gather-session-params (session)
    "Gather all params for a SESSION."
    (let (params)
      (dolist (repl (cdr session))
        (when (buffer-name repl)
          (setq params (cider--gather-connect-params params repl))))
      (when-let* ((server (cider--session-server session)))
        (setq params (cider--gather-connect-params params server)))
      params))
  )
(use-package flycheck-clj-kondo
  :ensure t)

Deletion in emacs.d/init.el at line 385 [7.136]
B:BD[19.789] → [19.789:825]
```
(use-package helm-cider :ensure t)
```

Replacement in emacs.d/init.el at line 404 [7.136]

B:BD[20.3463] → [20.3463:3609]

(defvar *fwoar-git-repos*
  (file-name-as-directory
   (expand-file-name (car (file-expand-wildcards "~/git*_repos"))
                     "~")))

[20.3463]

[19.1185]

(use-package browse-at-remote
  :after magit
  :ensure t
  :config (push (cons "gitlab.cj.com" "gitlab")
                browse-at-remote-remote-type-domains))

Replacement in emacs.d/init.el at line 410 [7.136]

B:BD[19.1186] → [21.411:463]

∅:D[21.463] → [20.3646:3770]

B:BD[20.3646] → [20.3646:3770]

B:BD[20.3770] → [21.464:636]

∅:D[21.636] → [20.3828:3843]

B:BD[20.3828] → [20.3828:3843]

(defun fwoar-git-repo (name ssh-remote http-remote)
  (let ((dir-name (file-name-as-directory (expand-file-name name *fwoar-git-repos*))))
    (unless (file-exists-p dir-name)
      (ecase fwoar-git-mode
        (:ssh (magit-run-git-with-input "clone" ssh-remote dir-name))
        (:http (magit-run-git-with-input "clone" http-remote dir-name))))
    dir-name))

[19.1186]

[20.3843]

(eval-and-compile
  (defvar *fwoar-git-repos*
    (file-name-as-directory
     (expand-file-name (car (file-expand-wildcards "~/git*_repos"))
                       "~"))))
(eval-and-compile
  (defun fwoar-git-repo (name ssh-remote http-remote)
    (let ((dir-name (file-name-as-directory (expand-file-name name *fwoar-git-repos*))))
      (unless (file-exists-p dir-name)
        (ecase fwoar-git-mode
          (:ssh (magit-run-git-with-input "clone" ssh-remote dir-name))
          (:http (magit-run-git-with-input "clone" http-remote dir-name))))
      dir-name)))

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

[5.4163]

(defun fwoar/cider-hook-base ()
  (flycheck-mode)
  (rainbow-delimiters-mode 1)
  (evil-smartparens-mode 1)
  (smartparens-strict-mode 1)
  (helm-cider-mode 1)
  (cider-company-enable-fuzzy-completion))
(defun fwoar/cider-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 1))
(defun fwoar/cider-repl-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 0))
(defun fwoar/cider-eval-expression-at-point-in-repl ()
  (interactive)
  (let ((form (cider-defun-at-point)))
    ;; Strip excess whitespace
    (while (string-match "\\`\s+\\|\n+\\'" form)
      (setq form (replace-match "" t t form)))
    (with-current-buffer (cider-current-repl nil t)
      (let ((fw/window (get-buffer-window)))
        (with-selected-window fw/window
          (end-of-buffer)
          (insert form)
          (cider-repl-return)
          (end-of-buffer))))))
(use-package cider
  :ensure t
  :config
  (require 'cider-selector)
  (define-key evil-normal-state-map " t" 'cider-test-run-ns-tests)
  (evil-define-key 'normal clojure-mode-map " '" 'helm-cider-apropos)
  (def-cider-selector-method ?S "find clojure project file"
    (fwoar--find-system))
  (add-hook 'cider-mode-hook 'fwoar/cider-hook)
  (add-hook 'cider-repl-mode-hook 'fwoar/cider-repl-hook)
  (modify-syntax-entry ?: "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?_ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?~ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?. "w" clojure-mode-syntax-table)
  (define-key cider-repl-mode-map (kbd "C-c M-o") 'cider-repl-clear-buffer)
  (define-key cider-repl-mode-map (kbd "C-c C-o") 'cider-repl-clear-output)
  (setq cider-save-file-on-load t
        cider-repl-history-file "~/.emacs.d/cider-history.clj")
  (define-key cider-mode-map
    (kbd "C-c C-j") 'fwoar/cider-eval-expression-at-point-in-repl))
(use-package flycheck-clj-kondo
  :ensure t)

File addition: cider-conf.el (----------)

[5.4163]

(defun fwoar/cider-hook-base ()
  (flycheck-mode)
  (rainbow-delimiters-mode 1)
  (evil-smartparens-mode 1)
  (smartparens-strict-mode 1)
  (helm-cider-mode 1)
  (cider-company-enable-fuzzy-completion))
(defun fwoar/cider-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 1))
(defun fwoar/cider-repl-hook ()
  (fwoar/cider-hook-base)
  (aggressive-indent-mode 0))
(defun fwoar/cider-eval-expression-at-point-in-repl ()
  (interactive)
  (let ((form (cider-defun-at-point)))
    ;; Strip excess whitespace
    (while (string-match "\\`\s+\\|\n+\\'" form)
      (setq form (replace-match "" t t form)))
    (with-current-buffer (cider-current-repl nil t)
      (let ((fw/window (get-buffer-window)))
        (with-selected-window fw/window
          (end-of-buffer)
          (insert form)
          (cider-repl-return)
          (end-of-buffer))))))
(use-package cider
  :ensure t
  :config
  (require 'cider-selector)
  (define-key evil-normal-state-map " t" 'cider-test-run-ns-tests)
  (evil-define-key 'normal clojure-mode-map " '" 'helm-cider-apropos)
  (def-cider-selector-method ?S "find clojure project file"
    (fwoar--find-system))
  (add-hook 'cider-mode-hook 'fwoar/cider-hook)
  (add-hook 'cider-repl-mode-hook 'fwoar/cider-repl-hook)
  (modify-syntax-entry ?: "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?_ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?~ "w" clojure-mode-syntax-table)
  (modify-syntax-entry ?. "w" clojure-mode-syntax-table)
  (define-key cider-repl-mode-map (kbd "C-c M-o") 'cider-repl-clear-buffer)
  (define-key cider-repl-mode-map (kbd "C-c C-o") 'cider-repl-clear-output)
  (setq cider-save-file-on-load t
        cider-repl-history-file "~/.emacs.d/cider-history.clj")
  (define-key cider-mode-map
    (kbd "C-c C-j") 'fwoar/cider-eval-expression-at-point-in-repl))
(use-package clj-refactor
  :after cider
  :ensure t
  :config
  (evil-define-key 'normal clojure-mode-map (kbd "SPC r") 'hydra-cljr-toplevel-form-menu/body))
(use-package helm-cider
  :after cider helm
  :ensure t)
(use-package flycheck-clj-kondo
  :after flycheck
  :ensure t)
(defun find-clojure-project-file ()
  (let ((systems (directory-files
                  (locate-dominating-file default-directory
                                          (lambda (n)
                                            (or (directory-files n nil "project.clj")
                                                (directory-files n nil "build.boot")
                                                (directory-files n nil "deps.edn")
                                                (directory-files n nil "shadow-cljs.edn"))))
                  t "^\\(project.clj\\|build.boot\\|deps.edn\\|shadow-cljs.edn\\)$")))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
(cl-defmethod fwoar--find-system (&context (major-mode (derived-mode clojure-mode)))
  (find-clojure-project-file))
(cl-defmethod fwoar--find-system (&context (major-mode (derived-mode cider-repl-mode)))
  (find-clojure-project-file))
(defmethod fwoar--pl-selector (&context (major-mode clojure-mode))
  (cider-selector))
(defmethod fwoar--pl-selector (&context (projectile-project-type (eql :clojure)))
  (cider-selector))
(defmethod fwoar--pl-selector (&context (major-mode cider-repl-mode))
  (cider-selector))

chore: cider configuration gets its own file

Dependencies

In channels

Change contents

File deletion: dependencies, dependencies

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

File addition: cider-conf.el (----------)

Deletion in emacs.d/init.el at line 313 [7.136]

Replacement in emacs.d/init.el at line 314 [7.136]

Deletion in emacs.d/init.el at line 317 [7.136]

Insertion in emacs.d/init.el at line 322 [7.136]

Deletion in emacs.d/init.el at line 324 [7.136]

Deletion in emacs.d/init.el at line 385 [7.136]

Replacement in emacs.d/init.el at line 404 [7.136]

Replacement in emacs.d/init.el at line 410 [7.136]

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

File addition: cider-conf.el (----------)