#+STARTUP: overview #+PROPERTY: header-args :comments yes :results silent

• Packages to add or look into

• embark
• consult
• marginalia
• MU4E Views
• crux
• perspetctiv
• tab bar
• literate calc mode
• org-superstar
• selectrum
• ctrlf
• moom
• telephone-line
• org-download
• spelling stuff
• eyebrowse
• smart-jump
• deadgrep
• rg
• diff-hl
• YCMD maybe for emacs and header file completions
• god mode
• mbsync
• popup-kill-ring
• discover-my-major
• treemacs (treemacs-magit, projectile)
• amx
• mathewZM
• ivy-omni-org
• ivy-explorer
• ivy-rich
• cloud-theme
• general.el
• focus mode
• multiple cursors again
• ranger /deer

• repos #+BEGIN_SRC emacs-lisp (add-to-list 'package-archives '("org" . "https://orgmode.org/elpa/") t)

#+END_SRC

• My Misc Functions #+BEGIN_SRC emacs-lisp

  (defun load-if-exists (f) "load the elisp file only if it exists and is readable" (if (file-readable-p f) (load-file f)))

  ;; font scaling (use-package default-text-scale :ensure t :config (global-set-key (kbd "C-M-=") 'default-text-scale-increase) (global-set-key (kbd "C-M--") 'default-text-scale-decrease))

;; narrow/widen dwim ; if you're windened, narrow to the region, if you're narrowed, widen ; bound to C-x n (defun narrow-or-widen-dwim (p) "If the buffer is narrowed, it widens. Otherwise, it narrows intelligently. Intelligently means: region, org-src-block, org-subtree, or defun, whichever applies first. Narrowing to org-src-block actually calls `org-edit-src-code'.

With prefix P, don't widen, just narrow even if buffer is already narrowed." (interactive "P") (declare (interactive-only)) (cond ((and (buffer-narrowed-p) (not p)) (widen)) ((region-active-p) (narrow-to-region (region-beginning) (region-end))) ((derived-mode-p 'org-mode) ;; `org-edit-src-code' is not a real narrowing command. ;; Remove this first conditional if you don't want it. (cond ((ignore-errors (org-edit-src-code)) (delete-other-windows)) ((org-at-block-p) (org-narrow-to-block)) (t (org-narrow-to-subtree)))) (t (narrow-to-defun))))

;; (define-key endless/toggle-map "n" #'narrow-or-widen-dwim) ;; This line actually replaces Emacs' entire narrowing keymap, that's ;; how much I like this command. Only copy it if that's what you want. (define-key ctl-x-map "n" #'narrow-or-widen-dwim)

#+END_SRC

• interface tweaks #+BEGIN_SRC emacs-lisp (setq inhibit-startup-message t) (tool-bar-mode -1) (fset 'yes-or-no-p 'y-or-n-p)

  (setenv "BROWSER" "firefox")t

  (use-package parchment-theme :ensure t) (use-package cloud-theme :ensure t) (use-package moe-theme :ensure t) (use-package zenburn-theme :ensure t) (use-package monokai-theme :ensure t) (use-package gruvbox-theme :ensure t) (use-package ample-theme :ensure t) (use-package ample-zen-theme :ensure t) (use-package alect-themes :ensure t) (use-package tao-theme :ensure t) (use-package poet-theme :ensure t) (use-package modus-operandi-theme :ensure t) (use-package modus-vivendi-theme :ensure t) (use-package faff-theme :ensure t) (use-package color-theme-modern :ensure t) (load-theme 'modus-operandi t)

  (use-package doom-modeline :ensure t) (doom-modeline-init)

  ;; expand the marked region in semantic increments ;;(negative prefix to reduce region) (use-package expand-region :ensure t :config (global-set-key (kbd "C-=") 'er/expand-region))

  (setq save-interprogram-paste-before-kill t)

  (use-package hungry-delete :ensure t :config (global-hungry-delete-mode))

  (global-auto-revert-mode 1) ;; you might not want this (setq auto-revert-verbose nil) ;; or this (global-set-key (kbd "") 'revert-buffer)

  (use-package aggressive-indent :ensure t :config ;; (global-aggressive-indent-mode 1) ;;(add-to-list 'aggressive-indent-excluded-modes 'html-mode) )

  (use-package ace-window :ensure t :config (setq aw-scope 'frame) ;; was global (global-set-key (kbd "C-x O") 'other-frame) (global-set-key [remap other-window] 'ace-window)) #+END_SRC

#+BEGIN_SRC emacs-lisp

(use-package try :ensure t) (use-package posframe :ensure t) (use-package iedit :ensure t)

(use-package which-key
  :ensure t 
  :config
  (which-key-mode))

#+END_SRC

#+BEGIN_SRC emacs-lisp (use-package pcre2el :ensure t :config (pcre-mode) )

(add-hook 'org-mode-hook 'turn-on-flyspell) (add-hook 'org-mode-hook 'turn-on-auto-fill) (add-hook 'mu4e-compose-mode-hook 'turn-on-flyspell) (add-hook 'mu4e-compose-mode-hook 'turn-on-auto-fill)

#+END_SRC

#+BEGIN_SRC emacs-lisp ;; (use-package hlinum ;; :ensure t ;; :config ;; (hlinum-activate) ;; (global-linum-mode)

;; ) #+END_SRC

• Selectrum / ctrlf

#+begin_src emacs-lisp :tangle no (use-package selectrum :ensure t) (selectrum-mode +1)

(use-package consult :ensure t) #+end_src

• Swiper / Ivy / Counsel Swiper gives us a really efficient incremental search with regular expressions and Ivy / Counsel replace a lot of ido or helms completion functionality #+BEGIN_SRC emacs-lisp

   (use-package counsel
  

  :ensure t :bind (("M-y" . counsel-yank-pop) :map ivy-minibuffer-map ("M-y" . ivy-next-line)))

  (use-package ivy :ensure t :diminish (ivy-mode) :bind (("C-x b" . ivy-switch-buffer)) :config (ivy-mode 1) (setq ivy-use-virtual-buffers t) (setq ivy-count-format "%d/%d ") (setq ivy-display-style 'fancy))

  ;; (use-package swiper
  ;; :ensure t
  ;; :bind (("C-s" . swiper-isearch)
  ;; 	 ("C-r" . swiper-isearch)
  ;; 	 ("C-c C-r" . ivy-resume)
  ;; 	 ("M-x" . counsel-M-x)
  ;; 	 ("C-x C-f" . counsel-find-file))
  ;; :config
  ;; (progn
  ;;   (ivy-mode 1)
  ;;   (setq ivy-use-virtual-buffers t)
  ;;   (setq ivy-display-style 'fancy)
  ;;   (define-key read-expression-map (kbd "C-r") 'counsel-expression-history)
  ;;   ))
  

  #+END_SRC

• CTRLF #+begin_src emacs-lisp (use-package ctrlf :ensure t) (ctrlf-mode +1)

#+end_src

• buffer stuff

#+begin_src emacs-lisp :tangle no (use-package bufler :ensure t) (defun mz/bufler-one-window (&optional force-refresh) (interactive "P") (bufler-list) (delete-other-windows)

)

(global-set-key (kbd "C-x C-b") 'mz/bufler-one-window)

#+end_src

#+BEGIN_SRC emacs-lisp

(global-set-key (kbd "C-x C-b") 'ibuffer) (setq ibuffer-saved-filter-groups (quote (("default" ("dired" (mode . dired-mode)) ("org" (name . "^.*org$")) ("magit" (mode . magit-mode)) ("IRC" (or (mode . circe-channel-mode) (mode . circe-server-mode))) ("web" (or (mode . web-mode) (mode . js2-mode))) ("shell" (or (mode . eshell-mode) (mode . shell-mode))) ("mu4e" (or

                      (mode . mu4e-compose-mode)
                      (name . "\*mu4e\*")
                      ))
             ("programming" (or
                             (mode . clojure-mode)
                             (mode . clojurescript-mode)
                             (mode . python-mode)
                             (mode . c++-mode)))
             ("emacs" (or
                       (name . "^\\*scratch\\*$")
                       (name . "^\\*Messages\\*$")))
             ))))

(add-hook 'ibuffer-mode-hook (lambda () (ibuffer-auto-mode 1) (ibuffer-switch-to-saved-filter-groups "default")))

;; don't show these ;(add-to-list 'ibuffer-never-show-predicates "zowie") ;; Don't show filter groups if there are no buffers in that group (setq ibuffer-show-empty-filter-groups nil)

;; Don't ask for confirmation to delete marked buffers (setq ibuffer-expert t)

#+END_SRC

• Flycheck #+BEGIN_SRC emacs-lisp (use-package flycheck :ensure t :init (global-flycheck-mode t))

  #+END_SRC

• Hydra #+BEGIN_SRC emacs-lisp (use-package hydra :ensure t)

#+END_SRC

• Folding - Origami #+BEGIN_SRC emacs-lisp (use-package origami :ensure t) #+END_SRC

#+BEGIN_SRC emacs-lisp (use-package origami :ensure t)

(defhydra hydra-origami (:color red) " _o_pen node _n_ext fold toggle _f_orward _c_lose node _p_revious fold toggle _a_ll " ("o" origami-open-node) ("c" origami-close-node) ("n" origami-next-fold) ("p" origami-previous-fold) ("f" origami-forward-toggle-node) ("a" origami-toggle-all-nodes))

#+END_SRC

• Magit and git stuff #+BEGIN_SRC emacs-lisp

;; some ediff settings (setq ediff-diff-options "") (setq ediff-custom-diff-options "-u") (setq ediff-window-setup-function 'ediff-setup-windows-plain) (setq ediff-split-window-function 'split-window-vertically)

(use-package magit :ensure t :init (progn (setq magit-section-initial-visibility-alist '((stashes . hide) (untracked . hide) (unpushed . hide)))

(bind-key "C-x g" 'magit-status)
))

(setq magit-status-margin '(t "%Y-%m-%d %H:%M " magit-log-margin-width t 18))

(use-package git-timemachine
:ensure t
)

(use-package git-gutter-fringe :ensure t :config (global-git-gutter-mode))

(use-package smerge-mode :after hydra :config (defhydra unpackaged/smerge-hydra (:color pink :hint nil :post (smerge-auto-leave)) " ^Move^ ^Keep^ ^Diff^ ^Other^ ^^-----------^^-------------------^^---------------------^^------- _n_ext _b_ase <: upper/base _C_ombine _p_rev _u_pper =: upper/lower _r_esolve ^^ _l_ower >: base/lower _k_ill current ^^ _a_ll _R_efine ^^ RET: current _E_diff " ("n" smerge-next) ("p" smerge-prev) ("b" smerge-keep-base) ("u" smerge-keep-upper) ("l" smerge-keep-lower) ("a" smerge-keep-all) ("RET" smerge-keep-current) ("\C-m" smerge-keep-current) ("<" smerge-diff-base-upper) ("=" smerge-diff-upper-lower) (">" smerge-diff-base-lower) ("R" smerge-refine) ("E" smerge-ediff) ("C" smerge-combine-with-next) ("r" smerge-resolve) ("k" smerge-kill-current) ("ZZ" (lambda () (interactive) (save-buffer) (bury-buffer)) "Save and bury buffer" :color blue) ("q" nil "cancel" :color blue)) :hook (magit-diff-visit-file . (lambda () (when smerge-mode (unpackaged/smerge-hydra/body)))))

(use-package forge :ensure t)

#+END_SRC

• ORG-mode stuff #+BEGIN_SRC emacs-lisp (use-package ox-reveal :ensure t) (require 'org-protocol) (custom-set-variables '(org-directory "~/Sync/orgfiles") '(org-default-notes-file (concat org-directory "/notes.org")) '(org-export-html-postamble nil) '(org-hide-leading-stars t) '(org-startup-folded (quote overview)) '(org-startup-indented t) '(org-confirm-babel-evaluate nil) '(org-src-fontify-natively t) '(org-export-with-toc nil) )

  (use-package org-bullets :ensure t :config (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))

  (global-set-key "\C-ca" 'org-agenda) (setq org-agenda-start-on-weekday nil) (setq org-agenda-custom-commands '(("c" "Simple agenda view" ((agenda "") (alltodo "")))))

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

  (setq org-agenda-files (list "~/opt/gcal.org" "~/opt/soe-cal.org" "~/Sync/orgfiles/i.org")) (setq org-capture-templates '(("l" "Link" entry (file+headline "~/Sync/orgfiles/links.org" "Links") "* %a %^g\n %?\n %T\n %i") ("b" "Blog idea" entry (file+headline "~/Sync/orgfiles/i.org" "POSTS:") "* %?\n%T" :prepend t) ("t" "To Do Item" entry (file+headline "~/Sync/orgfiles/i.org" "To Do and Notes") "* TODO %?\n%u" :prepend t) ("m" "Mail To Do" entry (file+headline "~/Sync/orgfiles/i.org" "To Do and Notes") "* TODO %a\n %?" :prepend t) ("n" "Note" entry (file+olp "~/Sync/orgfiles/i.org" "Notes") "* %u %? " :prepend t) ("r" "RSS" entry (file+headline "~/Sync/shared/elfeed.org" "Feeds misc") "** %A %^g\n") ))

  (use-package htmlize :ensure t)

  (setq org-ditaa-jar-path "/usr/share/ditaa/ditaa.jar") (setq org-file-apps (append '( ("\.pdf\'" . "evince %s") ("\.x?html?\'" . "/usr/bin/firefox %s") ) org-file-apps )) ;; babel stuff (require 'ob-clojure) (require 'ob-gnuplot) (require 'ob-prolog) (use-package ob-restclient :ensure t) (require 'ob-restclient) (setq org-babel-clojure-backend 'cider)

  (org-babel-do-load-languages 'org-babel-load-languages '((python . t) (prolog . t) (restclient . t) (emacs-lisp . t) (gnuplot . t) (shell . t) (java . t) (C . t) (clojure . t) (js . t) (ditaa . t) (dot . t) (org . t) (latex . t ) ))

  (setq mail-user-agent 'mu4e-user-agent) (use-package org-msg :ensure t :config (setq org-msg-options "html-postamble:nil H:5 num:nil ^:{} toc:nil tex:dvipng") (setq org-msg-startup "hidestars indent inlineimages") (setq org-msg-greeting-fmt "\n%s,\n\n") (setq org-msg-greeting-fmt-mailto t) (setq org-msg-signature " ,#+begin_signature -- Mike \\ ,#+end_signature") (org-msg-mode) )

  (require 'ox-reveal)

  (require 'org-tempo) ;; to bring back easy templates using <s or <n

  (require 'ox-publish) (setq org-publish-project-alist '(

        ("home_page"
         :base-directory "~/Sync/hunter/sites/home_page/"
         :base-extension "org"
         :publishing-directory "/ssh:[email protected]:/var/www/html/home_page/"
         :recursive t
         :publishing-function org-html-publish-to-html
         :headline-levels 4             ; Just the default for this project.
         :auto-preamble t
         )
  

("home_static" :base-directory "~/Sync/hunter/sites/home_page/" :base-extension "css\|js\|png\|jpg\|gif\|pdf\|mp3\|ogg\|swf" :publishing-directory "/ssh:[email protected]:/var/www/html/home_page/" :recursive t :publishing-function org-publish-attachment )

         ("teacher_ed"
         :base-directory "~/Sync/hunter/sites/teacher_ed/"
         :base-extension "org"
         :publishing-directory "/ssh:[email protected]:/var/www/html/teacher_ed/"
         :recursive t
         :publishing-function org-html-publish-to-html
         :headline-levels 4             ; Just the default for this project.
         :auto-preamble t
         )
        ))


(setq org-refile-targets '((nil :maxlevel . 2)))

#+END_SRC

• Parens #+BEGIN_SRC emacs-lisp (use-package smartparens :ensure t :config (require 'smartparens-config)

(add-hook 'minibuffer-setup-hook 'turn-on-smartparens-strict-mode)

;;;;;;;;;;;;;;;;;;;;;;;; ;; keybinding management (define-key smartparens-mode-map (kbd "C-M-f") 'sp-forward-sexp) (define-key smartparens-mode-map (kbd "C-M-b") 'sp-backward-sexp)

(define-key smartparens-mode-map (kbd "C-M-d") 'sp-down-sexp) (define-key smartparens-mode-map (kbd "C-M-a") 'sp-backward-down-sexp) (define-key smartparens-mode-map (kbd "C-S-d") 'sp-beginning-of-sexp) (define-key smartparens-mode-map (kbd "C-S-a") 'sp-end-of-sexp)

(define-key smartparens-mode-map (kbd "C-M-e") 'sp-up-sexp) (define-key smartparens-mode-map (kbd "C-M-u") 'sp-backward-up-sexp) (define-key smartparens-mode-map (kbd "C-M-t") 'sp-transpose-sexp)

(define-key smartparens-mode-map (kbd "C-M-n") 'sp-forward-hybrid-sexp) (define-key smartparens-mode-map (kbd "C-M-p") 'sp-backward-hybrid-sexp)

(define-key smartparens-mode-map (kbd "C-M-k") 'sp-kill-sexp) (define-key smartparens-mode-map (kbd "C-M-w") 'sp-copy-sexp)

(define-key smartparens-mode-map (kbd "M-") 'sp-unwrap-sexp) (define-key smartparens-mode-map (kbd "M-") 'sp-backward-unwrap-sexp)

(define-key smartparens-mode-map (kbd "C-") 'sp-forward-slurp-sexp) (define-key smartparens-mode-map (kbd "C-") 'sp-forward-barf-sexp) (define-key smartparens-mode-map (kbd "C-M-") 'sp-backward-slurp-sexp) (define-key smartparens-mode-map (kbd "C-M-") 'sp-backward-barf-sexp)

(define-key smartparens-mode-map (kbd "M-D") 'sp-splice-sexp) (define-key smartparens-mode-map (kbd "C-M-") 'sp-splice-sexp-killing-forward) (define-key smartparens-mode-map (kbd "C-M-") 'sp-splice-sexp-killing-backward) (define-key smartparens-mode-map (kbd "C-S-") 'sp-splice-sexp-killing-around)

(define-key smartparens-mode-map (kbd "C-]") 'sp-select-next-thing-exchange) (define-key smartparens-mode-map (kbd "C-<left_bracket>") 'sp-select-previous-thing) (define-key smartparens-mode-map (kbd "C-M-]") 'sp-select-next-thing)

(define-key smartparens-mode-map (kbd "M-F") 'sp-forward-symbol) (define-key smartparens-mode-map (kbd "M-B") 'sp-backward-symbol)

(define-key smartparens-mode-map (kbd "C-"") 'sp-change-inner) (define-key smartparens-mode-map (kbd "M-i") 'sp-change-enclosing)

(bind-key "C-c f" (lambda () (interactive) (sp-beginning-of-sexp 2)) smartparens-mode-map) (bind-key "C-c b" (lambda () (interactive) (sp-beginning-of-sexp -2)) smartparens-mode-map)

(bind-key "C-M-s" (defhydra smartparens-hydra () "Smartparens" ("d" sp-down-sexp "Down") ("e" sp-up-sexp "Up") ("u" sp-backward-up-sexp "Up") ("a" sp-backward-down-sexp "Down") ("f" sp-forward-sexp "Forward") ("b" sp-backward-sexp "Backward") ("k" sp-kill-sexp "Kill" :color blue) ("q" nil "Quit" :color blue)) smartparens-mode-map)

(bind-key "H-t" 'sp-prefix-tag-object smartparens-mode-map) (bind-key "H-p" 'sp-prefix-pair-object smartparens-mode-map) (bind-key "H-y" 'sp-prefix-symbol-object smartparens-mode-map) (bind-key "H-h" 'sp-highlight-current-sexp smartparens-mode-map) (bind-key "H-e" 'sp-prefix-save-excursion smartparens-mode-map) (bind-key "H-s c" 'sp-convolute-sexp smartparens-mode-map) (bind-key "H-s a" 'sp-absorb-sexp smartparens-mode-map) (bind-key "H-s e" 'sp-emit-sexp smartparens-mode-map) (bind-key "H-s p" 'sp-add-to-previous-sexp smartparens-mode-map) (bind-key "H-s n" 'sp-add-to-next-sexp smartparens-mode-map) (bind-key "H-s j" 'sp-join-sexp smartparens-mode-map) (bind-key "H-s s" 'sp-split-sexp smartparens-mode-map) (bind-key "H-s r" 'sp-rewrap-sexp smartparens-mode-map) (defvar hyp-s-x-map) (define-prefix-command 'hyp-s-x-map) (bind-key "H-s x" hyp-s-x-map smartparens-mode-map) (bind-key "H-s x x" 'sp-extract-before-sexp smartparens-mode-map) (bind-key "H-s x a" 'sp-extract-after-sexp smartparens-mode-map) (bind-key "H-s x s" 'sp-swap-enclosing-sexp smartparens-mode-map)

(bind-key "C-x C-t" 'sp-transpose-hybrid-sexp smartparens-mode-map)

(bind-key ";" 'sp-comment emacs-lisp-mode-map)

(bind-key [remap c-electric-backspace] 'sp-backward-delete-char smartparens-strict-mode-map)

;;;;;;;;;;;;;;;;;; ;; pair management

(sp-local-pair 'minibuffer-inactive-mode "'" nil :actions nil) (bind-key "C-(" 'sp---wrap-with-40 minibuffer-local-map)

(sp-with-modes 'org-mode (sp-local-pair "=" "=" :wrap "C-="))

(sp-with-modes 'textile-mode (sp-local-pair "" "") (sp-local-pair "" "") (sp-local-pair "@" "@"))

(sp-with-modes 'web-mode (sp-local-pair "{{#if" "{{/if") (sp-local-pair "{{#unless" "{{/unless"))

;;; tex-mode latex-mode (sp-with-modes '(tex-mode plain-tex-mode latex-mode) (sp-local-tag "i" ""<" "">"))

;;; lisp modes (sp-with-modes sp--lisp-modes (sp-local-pair "(" nil :wrap "C-(" :pre-handlers '(my-add-space-before-sexp-insertion) :post-handlers '(my-add-space-after-sexp-insertion)))

(defun my-add-space-after-sexp-insertion (id action _context) (when (eq action 'insert) (save-excursion (forward-char (sp-get-pair id :cl-l)) (when (or (eq (char-syntax (following-char)) ?w) (looking-at (sp--get-opening-regexp))) (insert " ")))))

(defun my-add-space-before-sexp-insertion (id action _context) (when (eq action 'insert) (save-excursion (backward-char (length id)) (when (or (eq (char-syntax (preceding-char)) ?w) (and (looking-back (sp--get-closing-regexp)) (not (eq (char-syntax (preceding-char)) ?')))) (insert " ")))))

;;; C++ (sp-with-modes '(malabar-mode c++-mode) (sp-local-pair "{" nil :post-handlers '(("||\n[i]" "RET")))) (sp-local-pair 'c++-mode "/" "/" :post-handlers '((" | " "SPC") ("* ||\n[i]" "RET")))

(setq-default sp-escape-quotes-after-insert nil)

(sp-local-pair 'js2-mode "/**" "/" :post-handlers '(("| " "SPC") (" ||\n[i]" "RET"))) (smartparens-global-mode) )

(use-package rainbow-delimiters :ensure t :config (add-hook 'clojure-mode-hook #'rainbow-delimiters-mode) ) (show-paren-mode t)

#+END_SRC

• Snippets #+BEGIN_SRC emacs-lisp (use-package yasnippet :ensure t :init (yas-global-mode 1))

  (use-package yasnippet-snippets :ensure t) (use-package yasnippet-classic-snippets :ensure t)

#+END_SRC

• Projectile #+BEGIN_SRC emacs-lisp

  (use-package projectile :ensure t :bind (:map projectile-mode-map ("s-p" . 'projectile-command-map) ("C-c p" . 'projectile-command-map) )

  :config 
  (setq projectile-completion-system 'ivy)
  
  (projectile-mode +1))
  

  ;; (use-package ibuffer-projectile ;; :ensure t ;; :config ;; (add-hook 'ibuffer-hook ;; (lambda () ;; (ibuffer-projectile-set-filter-groups) ;; (unless (eq ibuffer-sorting-mode 'alphabetic) ;; (ibuffer-do-sort-by-alphabetic)))) ;;) #+END_SRC

• Company #+BEGIN_SRC emacs-lisp (use-package company :ensure t :config (setq company-idle-delay 0) (setq company-minimum-prefix-length 3)

(global-company-mode t) )

#+END_SRC

• Dumb jump #+BEGIN_SRC emacs-lisp

(use-package dumb-jump :bind (("M-g o" . dumb-jump-go-other-window) ("M-g j" . dumb-jump-go) ("M-g x" . dumb-jump-go-prefer-external) ("M-g z" . dumb-jump-go-prefer-external-other-window)) :config ;; (setq dumb-jump-selector 'ivy) ;; (setq dumb-jump-selector 'helm) :init (dumb-jump-mode) :ensure )

#+END_SRC

• Restclient #+BEGIN_SRC emacs-lisp (use-package restclient :ensure t) (use-package company-restclient :ensure t :config (add-to-list 'company-backends 'company-restclient)) #+END_SRC

• Multiple Cursors #+BEGIN_SRC emacs-lisp (use-package multiple-cursors :ensure t )

(defhydra hydra-multiple-cursors (:hint nil) " Up^^ Down^^ Miscellaneous % 2(mc/num-cursors) cursor%s(if (> (mc/num-cursors) 1) "s" "")

[p] Next [n] Next [l] Edit lines [0] Insert numbers [P] Skip [N] Skip [a] Mark all [A] Insert letters [M-p] Unmark [M-n] Unmark [s] Search [Click] Cursor at point [q] Quit" ("l" mc/edit-lines :exit t) ("a" mc/mark-all-like-this :exit t) ("n" mc/mark-next-like-this) ("N" mc/skip-to-next-like-this) ("M-n" mc/unmark-next-like-this) ("p" mc/mark-previous-like-this) ("P" mc/skip-to-previous-like-this) ("M-p" mc/unmark-previous-like-this) ("s" mc/mark-all-in-region-regexp :exit t) ("0" mc/insert-numbers :exit t) ("A" mc/insert-letters :exit t) ("" mc/add-cursor-on-click) ;; Help with click recognition in this hydra ("" ignore) ("" ignore) ("q" nil))

#+END_SRC

• focus mode #+BEGIN_SRC emacs-lisp (use-package focus :ensure t ) #+END_SRC
• ivy-rich #+BEGIN_SRC emacs-lisp (use-package ivy-rich :ensure t :config (ivy-rich-mode 1) ) #+END_SRC
• eshell #+BEGIN_SRC emacs-lisp

(use-package exec-path-from-shell :ensure t :config (exec-path-from-shell-initialize))

(use-package fish-completion
:ensure t
:config
(global-fish-completion-mode))

;; (use-package eshell-prompt-extras ;; :ensure t ;; :config ;; (setq epe-show-python-info nil) ;; )

(use-package eshell-git-prompt :ensure t :config (eshell-git-prompt-use-theme 'git-radar) )

(setq scroll-step 1) #+END_SRC

#+BEGIN_SRC emacs-lisp (require 'cl-lib) (defun select-or-create (arg) "Commentary ARG." (if (string= arg "New eshell") (eshell t) (switch-to-buffer arg))) (defun eshell-switcher (&optional arg) "Commentary ARG." (interactive) (let* ( (buffers (cl-remove-if-not (lambda (n) (eq (buffer-local-value 'major-mode n) 'eshell-mode)) (buffer-list)) ) (names (mapcar (lambda (n) (buffer-name n)) buffers)) (num-buffers (length buffers) ) (in-eshellp (eq major-mode 'eshell-mode))) (cond ((eq num-buffers 0) (eshell (or arg t))) ((not in-eshellp) (switch-to-buffer (car buffers))) (t (select-or-create (completing-read "Select Shell:" (cons "New eshell" names)))))))

(defun eshell/in-term (prog &rest args) "Run shell command in term buffer." (switch-to-buffer (apply #'make-term prog prog nil args)) (term-mode) (term-char-mode))

#+END_SRC

• personal keymap #+BEGIN_SRC emacs-lisp

(defun org-agenda-show-agenda-and-todo (&optional arg) (interactive "P") (org-agenda arg "c") (org-agenda-fortnight-view))

(defun z/load-iorg () (interactive ) (find-file "~/Sync/orgfiles/i.org"))

;; set up my own map (define-prefix-command 'z-map) (global-set-key (kbd "C-z") 'z-map) ;; was C-1 (define-key z-map (kbd "k") 'compile) (define-key z-map (kbd "c") 'hydra-multiple-cursors/body) (define-key z-map (kbd "f") 'hydra-origami/body) (define-key z-map (kbd "m") 'mu4e) (define-key z-map (kbd "1") 'org-global-cycle) (define-key z-map (kbd "a") 'org-agenda-show-agenda-and-todo) (define-key z-map (kbd "g") 'counsel-ag) (define-key z-map (kbd "2") 'make-frame-command) (define-key z-map (kbd "0") 'delete-frame) (define-key z-map (kbd "o") 'other-frame)

(define-key z-map (kbd "s") 'flyspell-correct-word-before-point) (define-key z-map (kbd "i") 'z/load-iorg) (define-key z-map (kbd "*") 'calc) (define-key z-map (kbd "e") 'eshell-switcher)

(setq user-full-name "Mike Zamansky" user-mail-address "[email protected]") ;;--------------------------------------------------------------------------

(global-set-key (kbd "\e\ei") (lambda () (interactive) (find-file "~/Sync/orgfiles/i.org")))

(global-set-key (kbd "\e\el") (lambda () (interactive) (find-file "~/Sync/orgfiles/links.org")))

(global-set-key (kbd "\e\ec") (lambda () (interactive) (find-file "~/.emacs.d/README.org")))

(global-set-key (kbd "") 'move-end-of-line)

(global-set-key [mouse-3] 'flyspell-correct-word-before-point)

#+END_SRC

#+RESULTS: : origami-toggle-node

LocalWords: DIRED Javascript Screencasts Autocomplete

• Elfeed #+BEGIN_SRC emacs-lisp (setq elfeed-db-directory "~/Sync/shared/elfeeddb")

  (defun mz/elfeed-browse-url (&optional use-generic-p) "Visit the current entry in your browser using browse-url'. If there is a prefix argument, visit the current entry in the browser defined by browse-url-generic-program'." (interactive "P") (let ((entries (elfeed-search-selected))) (cl-loop for entry in entries do (if use-generic-p (browse-url-generic (elfeed-entry-link entry)) (browse-url (elfeed-entry-link entry)))) (mapc #'elfeed-search-update-entry entries) (unless (or elfeed-search-remain-on-entry (use-region-p)) ;;(forward-line) )))

  (defun elfeed-mark-all-as-read ()
        (interactive)
        (mark-whole-buffer)
        (elfeed-search-untag-all-unread))
  
  
  ;;functions to support syncing .elfeed between machines
  ;;makes sure elfeed reads index from disk before launching
  (defun bjm/elfeed-load-db-and-open ()
    "Wrapper to load the elfeed db from disk before opening"
    (interactive)
    (elfeed-db-load)
    (elfeed)
    (elfeed-search-update--force))
  
  ;;write to disk when quiting
  (defun bjm/elfeed-save-db-and-bury ()
    "Wrapper to save the elfeed db to disk before burying buffer"
    (interactive)
    (elfeed-db-save)
    (quit-window))
  
  
  
  
  (use-package elfeed
    :ensure t
    :bind (:map elfeed-search-mode-map
                ("q" . bjm/elfeed-save-db-and-bury)
                ("Q" . bjm/elfeed-save-db-and-bury)
                ("m" . elfeed-toggle-star)
                ("M" . elfeed-toggle-star)
                ("j" . mz/make-and-run-elfeed-hydra)
                ("J" . mz/make-and-run-elfeed-hydra)
                ("b" . mz/elfeed-browse-url)
                ("B" . elfeed-search-browse-url)
                )
  

  :config (defalias 'elfeed-toggle-star (elfeed-expose #'elfeed-search-toggle-all 'star))

    )
  
  (use-package elfeed-goodies
    :ensure t
    :config
    (elfeed-goodies/setup))
  
  
  (use-package elfeed-org
    :ensure t
    :config
    (elfeed-org)
    (setq rmh-elfeed-org-files (list "~/Sync/shared/elfeed.org")))
  

  (defun z/hasCap (s) "" (let ((case-fold-search nil)) (string-match-p "[[:upper:]]" s) ))

  (defun z/get-hydra-option-key (s) "returns single upper case letter (converted to lower) or first" (interactive) (let ( (loc (z/hasCap s))) (if loc (downcase (substring s loc (+ loc 1))) (substring s 0 1) )))

  ;; (active blogs cs eDucation emacs local misc sports star tech unread webcomics) (defun mz/make-elfeed-cats (tags) "Returns a list of lists. Each one is line for the hydra configuratio in the form (c function hint)" (interactive) (mapcar (lambda (tag) (let* ( (tagstring (symbol-name tag)) (c (z/get-hydra-option-key tagstring)) ) (list c (append '(elfeed-search-set-filter) (list (format "@6-months-ago +%s" tagstring) ))tagstring ))) tags))

  (defmacro mz/make-elfeed-hydra () `(defhydra mz/hydra-elfeed () "filter" ,@(mz/make-elfeed-cats (elfeed-db-get-all-tags)) ("*" (elfeed-search-set-filter "@6-months-ago +star") "Starred") ("M" elfeed-toggle-star "Mark") ("A" (elfeed-search-set-filter "@6-months-ago") "All") ("T" (elfeed-search-set-filter "@1-day-ago") "Today") ("Q" bjm/elfeed-save-db-and-bury "Quit Elfeed" :color blue) ("q" nil "quit" :color blue) ))

  (defun mz/make-and-run-elfeed-hydra ()
    ""
    (interactive)
    (mz/make-elfeed-hydra)
    (mz/hydra-elfeed/body))
  

  (defun my-elfeed-tag-sort (a b) (let* ((a-tags (format "%s" (elfeed-entry-tags a))) (b-tags (format "%s" (elfeed-entry-tags b)))) (if (string= a-tags b-tags) (< (elfeed-entry-date b) (elfeed-entry-date a))) (string< a-tags b-tags)))

  (setf elfeed-search-sort-function #'my-elfeed-tag-sort) #+END_SRC

• dired stuff #+BEGIN_SRC emacs-lisp (use-package diredfl :ensure t :config (diredfl-global-mode 1))

(setq dired-listing-switches "-lXGh --group-directories-first" dired-dwim-target t) (add-hook 'dired-mode-hook 'dired-hide-details-mode)

(use-package dired-recent :ensure t :config

(dired-recent-mode 1) )

(defun my-dired-recent-dirs () "Present a list of recently used directories and open the selected one in dired" (interactive) (let ((dir (ivy-read "Directory: " dired-recent-directories :re-builder #'ivy--regex :sort nil :initial-input nil))) (dired dir)))

(setq dired-guess-shell-alist-user '(("" "xdg-open")))

#+END_SRC ** floobits #+begin_src emacs-lisp (use-package floobits :ensure t) #+end_src

• RG - ripgrep #+begin_src emacs-lisp (use-package rg :ensure t :config (rg-enable-default-bindings)) ;;(rg-enable-menu)) #+end_src
• open alternative from Xah Lee #+begin_src emacs-lisp (defun xah-open-in-external-app (&optional @fname) "Open the current file or dired marked files in external app. The app is chosen from your OS's preference.

When called in emacs lisp, if @fname is given, open that.

URL `http://ergoemacs.org/emacs/emacs_dired_open_file_in_ext_apps.html' Version 2019-11-04" (interactive) (let* ( ($file-list (if @fname (progn (list @fname)) (if (string-equal major-mode "dired-mode") (dired-get-marked-files) (list (buffer-file-name))))) ($do-it-p (if (<= (length $file-list) 5) t (y-or-n-p "Open more than 5 files? ")))) (when $do-it-p (cond ((string-equal system-type "windows-nt") (mapc (lambda ($fpath) (w32-shell-execute "open" $fpath)) $file-list)) ((string-equal system-type "darwin") (mapc (lambda ($fpath) (shell-command (concat "open " (shell-quote-argument $fpath)))) $file-list)) ((string-equal system-type "gnu/linux") (mapc (lambda ($fpath) (let ((process-connection-type nil)) (start-process "" nil "xdg-open" $fpath))) $file-list))))))

(define-key dired-mode-map (kbd "C-") 'xah-open-in-external-app) #+end_src

• misc #+begin_src emacs-lisp (setq confirm-kill-processes nil)

#+end_src

• Clojure #+BEGIN_SRC emacs-lisp (use-package cider :ensure t :config (add-hook 'cider-repl-mode-hook #'company-mode) (add-hook 'cider-mode-hook #'company-mode) (add-hook 'cider-mode-hook #'eldoc-mode) ;; (add-hook 'cider-mode-hook #'cider-hydra-mode) (setq cider-repl-use-pretty-printing t) (setq cider-repl-display-help-banner nil) ;; (setq cider-cljs-lein-repl "(do (use 'figwheel-sidecar.repl-api) (start-figwheel!) (cljs-repl))")

  :bind (("M-r" . cider-namespace-refresh) ("C-c r" . cider-repl-reset) ("C-c ." . cider-reset-test-run-tests)) )

(defun my-clojure-mode-hook () (clj-refactor-mode 1) (yas-minor-mode 1) ; for adding require/use/import statements ;; This choice of keybinding leaves cider-macroexpand-1 unbound (cljr-add-keybindings-with-prefix "C-c C-m")) (use-package clj-refactor :ensure t :config (add-hook 'clojure-mode-hook #'my-clojure-mode-hook))

#+END_SRC

• Python #+begin_src emacs-lisp ;; set the python interpeter (setq python-shell-interpreter "python3")

#+end_src

• lsp #+begin_src emacs-lisp :tangle no ;; set prefix for lsp-command-keymap (few alternatives - "s-l", "C-l") (setq lsp-keymap-prefix "C-c l") (setq company-clang-executable "/usr/bin/clangd-10") (setq lsp-clients-clangd-executable "/usr/bin/clangd-10")

  (use-package lsp-mode :ensure t :commands lsp :hook ((c-mode c++-mode python-mode) . lsp) )

  (use-package lsp-treemacs :ensure t) (add-hook 'c-mode-hook 'lsp) (add-hook 'c++-mode-hook 'lsp) (add-hook 'cpp-mode-hook 'lsp) (setq lsp-enabled-clients '(jedi clangd)) (use-package lsp-ui :ensure t :hook (lsp-mode . lsp-ui-mode) :config (setq lsp-ui-sideline-enable t) (setq lsp-ui-sideline-show-hover nil) (setq lsp-ui-doc-position 'bottom) ;; lsp config stuff (setq lsp-enable-links nil) (setq lsp-signature-render-documentation nil) (setq lsp-headerline-breadcrumb-enable nil) (setq lsp-ui-doc-enable nil) (setq lsp-completion-enable-additional-text-edit nil) (setq web-mode-enable-current-element-highlight t) (lsp-ui-doc-show))

  (use-package lsp-jedi :ensure t :config (with-eval-after-load "lsp-mode" (add-to-list 'lsp-disabled-clients 'pyls) (add-to-list 'lsp-enabled-clients 'jedi)))

  (setq lsp-ui-doc-show-with-cursor nil)

  ;; (use-package dap-mode ;; :ensure t ;; :hook (lsp-mode . dap-mode) ;; :config ;; (dap-ui-mode 1) ;; (dap-tooltip-mode 1) ;; (require 'dap-node) ;; (dap-node-setup))

  ;; (dap-auto-configure-mode) ;; (require 'dap-gdb-lldb) ;; (require 'dap-cpptools) ;; https://emacs-lsp.github.io/lsp-mode/tutorials/how-to-turn-off/

#+end_src

• eglot - C++, Python, Java :tangle no #+begin_src emacs-lisp

(use-package eglot :ensure t) (add-to-list 'eglot-server-programs '((c++-mode c-mode) "clangd-10")) (add-hook 'c-mode-hook 'eglot-ensure) (add-hook 'c++-mode-hook 'eglot-ensure)

(add-hook 'python-mode-hook 'eglot-ensure)

(defconst my-eclipse-jdt-home "/home/zamansky/.emacs.d/.cache/lsp/eclipse.jdt.ls/plugins/org.eclipse.equinox.launcher_1.5.800.v20200727-1323.jar") (defun my-eglot-eclipse-jdt-contact (interactive) "Contact with the jdt server input INTERACTIVE." (let ((cp (getenv "CLASSPATH"))) (setenv "CLASSPATH" (concat cp ":" my-eclipse-jdt-home)) (unwind-protect (eglot--eclipse-jdt-contact nil) (setenv "CLASSPATH" cp)))) (setcdr (assq 'java-mode eglot-server-programs) #'my-eglot-eclipse-jdt-contact)

(add-hook 'java-mode-hook 'eglot-ensure)

#+end_src

• Load other files #+BEGIN_SRC emacs-lisp

  (load-if-exists "~/Sync/shared/mu4econfig.el") (load-if-exists "~/Sync/shared/not-for-github.el")

  #+END_SRC

• Temp testing stuff #+begin_src emacs-lisp ;;(set-frame-font "Inconsolata-18") (set-frame-font "Firacode-18") #+end_src