GuangTao's Doom Emacs config

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

;;; init.el -*- lexical-binding: t; -*-

;; Copy this file to ~/.doom.d/init.el or ~/.config/doom/init.el ('doom install'
;; will do this for you). The `doom!' block below controls what modules are
;; enabled and in what order they will be loaded. Remember to run 'doom refresh'
;; after modifying it.
;;
;; More information about these modules (and what flags they support) can be
;; found in modules/README.org.

(doom! :input
       chinese
       ;;japanese
       :completion
       company           ; the ultimate code completion backend
       ;;helm              ; the *other* search engine for love and life
       ;;ido               ; the other *other* search engine...
       ivy               ; a search engine for love and life
       :ui
       ;;deft              ; notational velocity for Emacs
       doom              ; what makes DOOM look the way it does
       doom-dashboard    ; a nifty splash screen for Emacs
       doom-quit         ; DOOM quit-message prompts when you quit Emacs
       ;;fill-column       ; a `fill-column' indicator
       hl-todo           ; highlight TODO/FIXME/NOTE/DEPRECATED/HACK/REVIEW
       ;;hydra
       indent-guides     ; highlighted indent columns
       modeline          ; snazzy, Atom-inspired modeline, plus API
       nav-flash         ; blink the current line after jumping
       ;;neotree           ; a project drawer, like NERDTree for vim
       ophints           ; highlight the region an operation acts on
       (popup +defaults)   ; tame sudden yet inevitable temporary windows
       ;;pretty-code       ; replace bits of code with pretty symbols
       ;;tabs              ; an tab bar for Emacs
       treemacs          ; a project drawer, like neotree but cooler
       ;;unicode           ; extended unicode support for various languages
       vc-gutter         ; vcs diff in the fringe
       vi-tilde-fringe   ; fringe tildes to mark beyond EOB
       window-select     ; visually switch windows
       workspaces        ; tab emulation, persistence & separate workspaces

       :editor
       ;;(evil +everywhere); come to the dark side, we have cookies
       file-templates    ; auto-snippets for empty files
       ;;god               ; run Emacs commands without modifier keys
       fold              ; (nigh) universal code folding
       ;;(format +onsave)  ; automated prettiness
       ;;lispy             ; vim for lisp, for people who dont like vim
       ;;multiple-cursors  ; editing in many places at once
       ;;objed             ; text object editing for the innocent
       ;;parinfer          ; turn lisp into python, sort of
       rotate-text       ; cycle region at point between text candidates
       snippets          ; my elves. They type so I don't have to
       ;;word-wrap         ; soft wrapping with language-aware indent

       :emacs
       dired             ; making dired pretty [functional]
       electric          ; smarter, keyword-based electric-indent
       ibuffer           ; interactive buffer management
       vc                ; version-control and Emacs, sitting in a tree

       :term
       ;;eshell            ; a consistent, cross-platform shell (WIP)
       ;;shell             ; a terminal REPL for Emacs
       ;;term              ; terminals in Emacs
       vterm             ; another terminals in Emacs

       :checkers
       syntax              ; tasing you for every semicolon you forget
       ;;spell             ; tasing you for misspelling mispelling
       ;;grammar           ; tasing grammar mistake every you make

       :tools
       ;;ansible
       ;;debugger          ; FIXME stepping through code, to help you add bugs
       ;;direnv
       ;;docker
       ;;editorconfig      ; let someone else argue about tabs vs spaces
       ;;ein               ; tame Jupyter notebooks with emacs
       (eval +overlay)     ; run code, run (also, repls)
       ;;flycheck          ; tasing you for every semicolon you forget
       ;;flyspell          ; tasing you for misspelling mispelling
       ;;gist              ; interacting with github gists
       (lookup           ; helps you navigate your code and documentation
        +docsets)        ; ...or in Dash docsets locally
       lsp
       ;;macos             ; MacOS-specific commands
       magit             ; a git porcelain for Emacs
       ;;make              ; run make tasks from Emacs
       ;;pass              ; password manager for nerds
       pdf               ; pdf enhancements
       ;;prodigy           ; FIXME managing external services & code builders
       ;;rgb               ; creating color strings
       ;;terraform         ; infrastructure as code
       ;;tmux              ; an API for interacting with tmux
       ;;upload              ; map local to remote projects via ssh/ftp
       ;;wakatime

       :os
       (:if IS-MAC macos)  ; improve compatibility with macOS

       :lang
       ;;agda              ; types of types of types of types...
       ;;assembly          ; assembly for fun or debugging
       (cc
          +lsp)                              ; C/C++/Obj-C madness
       ;;clojure           ; java with a lisp
       common-lisp       ; if you've seen one lisp, you've seen them all
       ;;coq               ; proofs-as-programs
       ;;crystal           ; ruby at the speed of c
       ;;csharp            ; unity, .NET, and mono shenanigans
       data              ; config/data formats
       ;;erlang            ; an elegant language for a more civilized age
       ;;elixir            ; erlang done right
       ;;elm               ; care for a cup of TEA?
       emacs-lisp        ; drown in parentheses
       ess               ; emacs speaks statistics
       ;;faust             ; dsp, but you get to keep your soul
       ;;fsharp           ; ML stands for Microsoft's Language
       go                ; the hipster dialect
       json

       haskell ; a language that's lazier than I am
       ;;hy                ; readability of scheme w/ speed of python
       ;;idris             ;
       ;;(java +meghanada) ; the poster child for carpal tunnel syndrome
       ;;javascript        ; all(hope(abandon(ye(who(enter(here))))))
       julia             ; a better, faster MATLAB
       ;;kotlin            ; a better, slicker Java(Script)
       latex             ; writing papers in Emacs has never been so fun
       ;;lean
       ;;ledger            ; an accounting system in Emacs
       ;;lua               ; one-based indices? one-based indices
       markdown          ; writing docs for people to ignore
       ;;nim               ; python + lisp at the speed of c
       nix               ; I hereby declare "nix geht mehr!"
       ;;ocaml             ; an objective camel
       (org              ; organize your plain life in plain text
        +dragndrop       ; drag & drop files/images into org buffers
        +hugo            ; use Emacs for hugo blogging
        +ipython         ; ipython/jupyter support for babel
        +pandoc          ; export-with-pandoc support
        +journal
        +roam
        ;;+helm-org
        ;+pomodoro        ; be fruitful with the tomato technique
        +present)        ; using org-mode for presentations
       ;;perl              ; write code no one else can comprehend
       ;;php               ; perl's insecure younger brother
       plantuml          ; diagrams for confusing people more
       ;;purescript        ; javascript, but functional
       (python
        +poetry
        +lsp
        +pyright)            ; beautiful is better than ugly
       ;;qt                ; the 'cutest' gui framework ever
       ;;racket            ; a DSL for DSL
       ;;ruby              ; 1.step {|i| p "Ruby is #{i.even? ? 'love' : 'life'}"}
       rust              ; Fe2O3.unwrap().unwrap().unwrap().unwrap()
       ;;scala             ; java, but good
       ;;scheme            ; a fully conniving family of lisps
       sh                ; she sells {ba,z,fi}sh shells on the C xor
       ;;solidity          ; do you need a blockchain? No.
       ;;swift             ; who asked for emoji variables?
       ;;terra             ; Earth and Moon in alignment for performance.
       ;;web               ; the tubes

       :email
       ;;(mu4e +gmail)       ; WIP
       ;;notmuch             ; WIP
       ;;(wanderlust +gmail) ; WIP

       ;; Applications are complex and opinionated modules that transform Emacs
       ;; toward a specific purpose. They may have additional dependencies and
       ;; should be loaded late.
       :app
       ;;calendar
       ;;irc               ; how neckbeards socialize
       ;;(rss +org)        ; emacs as an RSS reader
       ;;twitter           ; twitter client https://twitter.com/vnought
       ;;(write            ; emacs for writers (fiction, notes, papers, etc.)
       ;; +wordnut         ; wordnet (wn) search
       ;; +langtool)       ; a proofreader (grammar/style check) for Emacs

       :config
       ;; For literate config users. This will tangle+compile a config.org
       ;; literate config in your `doom-private-dir' whenever it changes.
       literate

       ;; The default module sets reasonable defaults for Emacs. It also
       ;; provides a Spacemacs-inspired keybinding scheme and a smartparens
       ;; config. Use it as a reference for your own modules.
       ;;(default +smartparens)
         :private
         spacemacs-default
         my-org
         my-code
         )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

;;; packages.el -*- lexical-binding: t; -*-
(package! discover :recipe (:host github :repo "mickeynp/discover.el"))
(package! maple-iedit :recipe (:host github :repo "honmaple/emacs-maple-iedit"))
(package! scrollkeeper :recipe (:host github :repo "alphapapa/scrollkeeper.el"))
(package! awesome-tab :recipe (:host github :repo "manateelazycat/awesome-tab"))
(package! ob-session-async :recipe (:host github :repo "jackkamm/ob-session-async"))
(package! maple-explorer :recipe (:host github :repo "honmaple/emacs-maple-explorer"))
(package! sunrise-commander :recipe (:host github :repo "sunrise-commander/sunrise-commander"))
(package! awesome-pair :recipe (:host github :repo "manateelazycat/awesome-pair"))
(package! meow :recipe (:host github :repo "DogLooksGood/meow"))
;; (package! berrys-theme)

1
2
3

;;; config.el -*- lexical-binding: t; -*-
(load! "show-parentheses.el")
(load! "meow.el")

1

;;(setq comp-async-jobs-number 24)

1

(package! helm-tramp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

(use-package! helm-tramp
  :config
  (setq tramp-default-method "sshx")
  (setq make-backup-files nil)
  (setq create-lockfiles nil)
  (setq helm-tramp-custom-connections '(/sshx:gtrun@10.220.170.112:/home/gtrun
                                        /sshx:gtrun@10.220.170.112:/home/gtrun/.config/nixpkgs
                                        /sshx:test@10.220.170.134:/home/test/))
  (add-hook 'helm-tramp-pre-command-hook '(lambda () ;;(global-aggressive-indent-mode 0)
                     (projectile-mode 0)
                     ;;(editorconfig-mode 0)
             ))
  (add-hook 'helm-tramp-quit-hook '(lambda () ;;(global-aggressive-indent-mode 1)
                  (projectile-mode 1)
                  ;;(editorconfig-mode 1)
            ))
)

1

t

1

(package! pinyin-search)

1

(use-package! pinyin-search)

1

(package! wakatime-mode)

1
2

(use-package! wakatime-mode
:hook (after-init . global-wakatime-mode))

1

(package! vlf)

1
2
3
4
5
6

(use-package! vlf
  :config
  (require 'vlf-setup)
  (custom-set-variables
   '(vlf-application 'dont-ask))
)

1
2
3
4
5
6
7
8

(use-package! maple-explorer
  :commands (maple-explorer-file maple-explorer-buffer maple-explorer-imenu maple-explorer-recentf)
  :config
  (setq maple-explorer-file-display-alist '((side . left) (slot . -1)))
  (add-hook 'maple-explorer-imenu-mode-hook
            (lambda() (setq cursor-type 'box
                            cursor-in-non-selected-windows t)))
)

1

(package! imenu-list)

1
2
3
4
5
6
7

(use-package! imenu-list
  :config
  (setq imenu-list-auto-resize t)
  (setq imenu-list-focus-after-activation t)
  (setq imenu-list-after-jump-hook nil)
  (add-hook 'menu-list-after-jump-hook #'recenter-top-bottom)
)

1

(package! w3m)

1
2
3
4
5

(use-package! w3m
  :commands (w3m)
  :config
  (setq w3m-use-tab-line nil)
)

1
2
3
4

(package! ein :recipe (:host github
                       :repo "millejoh/emacs-ipython-notebook"
                       :files ("lisp/*.el")
                       :build (:not compile)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

(use-package! ein
  :config
  (setq ob-ein-languages
   (quote
    (("ein-python" . python)
     ("ein-R" . R)
     ("ein-r" . R)
     ("ein-rust" . rust)
     ("ein-haskell" . haskell)
     ("ein-julia" . julia))))
  )

(after! ein:ipynb-mode                  ;
  (poly-ein-mode 1)
  (hungry-delete-mode -1)
  )

1
2

(package! undo-fu)
(package! undo-fu-session)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

(use-package! undo-fu
  :after-call doom-switch-buffer after-find-file
  :init
  (after! undo-tree
    (global-undo-tree-mode -1))
  :config
  ;; Store more undo history to prevent loss of data
  (setq undo-limit 400000
        undo-strong-limit 3000000
        undo-outer-limit 3000000)

  (define-minor-mode undo-fu-mode
    "Enables `undo-fu' for the current session."
    :keymap (let ((map (make-sparse-keymap)))
              (define-key map [remap undo] #'undo-fu-only-undo)
              (define-key map [remap redo] #'undo-fu-only-redo)
              (define-key map (kbd "C-_")     #'undo-fu-only-undo)
              (define-key map (kbd "M-_")     #'undo-fu-only-redo)
              (define-key map (kbd "C-M-_")   #'undo-fu-only-redo-all)
              (define-key map (kbd "C-x r u") #'undo-fu-session-save)
              (define-key map (kbd "C-x r U") #'undo-fu-session-recover)
              map)
    :init-value nil
    :global t)

  (undo-fu-mode +1))

(use-package! undo-fu-session
  :hook (undo-fu-mode . global-undo-fu-session-mode)
  :preface
  (setq undo-fu-session-directory (concat doom-cache-dir "undo-fu-session/")
        undo-fu-session-incompatible-files '("/COMMIT_EDITMSG\\'" "/git-rebase-todo\\'"))

  ;; HACK We avoid `:config' here because `use-package's `:after' complicates
  ;;      the load order of a package's `:config' block and makes it impossible
  ;;      for the user to override its settings with merely `after!' (or
  ;;      `eval-after-load'). See jwiegley/use-package#829.
  (after! undo-fu-session
    ;; HACK Use the faster zstd to compress undo files instead of gzip
    (when (executable-find "zstd")
      (defadvice! doom--undo-fu-session-use-zstd-a (filename)
        :filter-return #'undo-fu-session--make-file-name
        (if undo-fu-session-compression
            (concat (file-name-sans-extension filename) ".zst")
          filename)))))

(use-package! undo-tree
  :disabled
  ;; Branching & persistent undo
  :after-call doom-switch-buffer-hook after-find-file
  :config
  (setq undo-tree-visualizer-diff t
        undo-tree-auto-save-history t
        undo-tree-enable-undo-in-region t
        ;; Increase undo-limits by a factor of ten to avoid emacs prematurely
        ;; truncating the undo history and corrupting the tree. See
        ;; https://github.com/syl20bnr/spacemacs/issues/12110
        undo-limit 800000
        undo-strong-limit 12000000
        undo-outer-limit 120000000
        undo-tree-history-directory-alist
        `(("." . ,(concat doom-cache-dir "undo-tree-hist/"))))

  ;; Compress undo-tree history files with zstd, if available. File size isn't
  ;; the (only) concern here: the file IO barrier is slow for Emacs to cross;
  ;; reading a tiny file and piping it in-memory through zstd is *slightly*
  ;; faster than Emacs reading the entire undo-tree file from the get go (on
  ;; SSDs). Whether or not that's true in practice, we still enjoy zstd's ~80%
  ;; file savings (these files add up over time and zstd is so incredibly fast).
  (when (executable-find "zstd")
    (defadvice! doom--undo-tree-make-history-save-file-name-a (file)
      :filter-return #'undo-tree-make-history-save-file-name
      (concat file ".zst")))

  ;; Strip text properties from undo-tree data to stave off bloat. File size
  ;; isn't the concern here; undo cache files bloat easily, which can cause
  ;; freezing, crashes, GC-induced stuttering or delays when opening files.
  (defadvice! doom--undo-tree-strip-text-properties-a (&rest _)
    :before #'undo-list-transfer-to-tree
    (dolist (item buffer-undo-list)
      (and (consp item)
           (stringp (car item))
           (setcar item (substring-no-properties (car item))))))

  ;; Undo-tree is too chatty about saving its history files. This doesn't
  ;; totally suppress it logging to *Messages*, it only stops it from appearing
  ;; in the echo-area.
  (advice-add #'undo-tree-save-history :around #'doom-shut-up-a)

  (global-undo-tree-mode +1))

1

(package! vundo :recipe (:host github :repo "casouri/vundo"))

1

(use-package! vundo)

1

(package! color-rg :recipe (:host github :repo "manateelazycat/color-rg"))

1
2
3
4
5
6
7
8

(use-package! color-rg
  :commands (color-rg-search-input color-rg-search-symbol
                                   color-rg-search-input-in-project
                                   )
  :bind
  (:map isearch-mode-map
   ("M-s M-s" . isearch-toggle-color-rg))
  )

1

(package! envrc :recipe (:host github :repo "purcell/envrc"))

1
2
3

(use-package! envrc
:hook (after-init . envrc-global-mode)
)

1
2
3

  (package! snails :recipe (:host github
                            :repo "manateelazycat/snails"
                            :files ("*.el")))

1
2
3
4
5
6

;; (use-package! snails
;;   :config
;;   (setq snails-show-with-frame nil)
;;   (define-key snails-mode-map [remap previous-line] #'snails-select-prev-item)
;;   (define-key snails-mode-map [remap next-line] #'snails-select-next-item)
;;   )

1
2

(package! iscroll :recipe (:host github
                                 :repo "casouri/iscroll"))

1
2
3
4

(use-package! iscroll
  :config
  (add-hook! 'org-mode-hook 'iscroll-mode)
  )

1

(package! helm-rg)

1

(use-package! helm-rg)

1
2
3

(package! fd-dired :recipe (:host github
                                 :repo "yqrashawn/fd-dired"))

1

(use-package! fd-dired)

1
2
3

(package! find-dupes-dired :recipe (:host github
                                 :repo "ShuguangSun/find-dupes-dired"))

1

(use-package! find-dupes-dired)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

;;; ~/.doom.d/autoload/misc.el -*- lexical-binding: t; -*-
(defvar current-date-time-format "%a %b %d %H:%M:%S %Z %Y"

  "Format of date to insert with `insert-current-date-time' func
See help of `format-time-string' for possible replacements")

;;;###autoload
(defun insert-current-date-time ()
  "insert the current date and time into current buffer.
Uses `current-date-time-format' for the formatting the date/time."
       (interactive)
       ;;(insert "==========\n")
;       (insert (let () (comment-start)))
       (insert (format-time-string current-date-time-format (current-time)))
       )

(defvar current-date-time-format-inactive "[%Y-%m-%d %a %H:%M]"

  "Format of date to insert with `insert-current-date-time' func
See help of `format-time-string' for possible replacements")

;;;###autoload
(defun insert-current-date-time-inactive
 ()
  "insert the current date and time into current buffer.
Uses `current-date-time-format' for the formatting the date/time."
       (interactive)
       ;;(insert "==========\n")
;       (insert (let () (comment-start)))
       (insert (format-time-string current-date-time-format-inactive (current-time)))
       ;;(insert "\n")
       )

(defvar current-date-time-format-active "<%Y-%m-%d %a %H:%M>"

  "Format of date to insert with `insert-current-date-time' func
See help of `format-time-string' for possible replacements")

;;;###autoload
(defun insert-current-date-time-active
 ()
  "insert the current date and time into current buffer.
Uses `current-date-time-format' for the formatting the date/time."
       (interactive)
       ;;(insert "==========\n")
;       (insert (let () (comment-start)))
       (insert (format-time-string current-date-time-format-active (current-time)))
       ;;(insert "\n")
       )

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

;;; ~/.doom.d/autoload/+org-mode.el -*- lexical-binding: t; -*-
(defun unpackaged/org-element-descendant-of (type element)
  "Return non-nil if ELEMENT is a descendant of TYPE.
TYPE should be an element type, like `item' or `paragraph'.
ELEMENT should be a list like that returned by `org-element-context'."
  ;; MAYBE: Use `org-element-lineage'.
  (when-let* ((parent (org-element-property :parent element)))
    (or (eq type (car parent))
        (unpackaged/org-element-descendant-of type parent))))

;;;###autoload
(defun unpackaged/org-fix-blank-lines (&optional prefix)
  "Ensure that blank lines exist between headings and between headings and their contents.
With prefix, operate on whole buffer. Ensures that blank lines
exist after each headings's drawers."
  (interactive "P")
  (org-map-entries (lambda ()
                     (org-with-wide-buffer
                      ;; `org-map-entries' narrows the buffer, which prevents us from seeing
                      ;; newlines before the current heading, so we do this part widened.
                      (while (not (looking-back "\n\n" nil))
                        ;; Insert blank lines before heading.
                        (insert "\n")))
                     (let ((end (org-entry-end-position)))
                       ;; Insert blank lines before entry content
                       (forward-line)
                       (while (and (org-at-planning-p)
                                   (< (point) (point-max)))
                         ;; Skip planning lines
                         (forward-line))
                       (while (re-search-forward org-drawer-regexp end t)
                         ;; Skip drawers. You might think that `org-at-drawer-p' would suffice, but
                         ;; for some reason it doesn't work correctly when operating on hidden text.
                         ;; This works, taken from `org-agenda-get-some-entry-text'.
                         (re-search-forward "^[ \t]*:END:.*\n?" end t)
                         (goto-char (match-end 0)))
                       (unless (or (= (point) (point-max))
                                   (org-at-heading-p)
                                   (looking-at-p "\n"))
                         (insert "\n"))))
                   t (if prefix
                         nil
                       'tree)))


;;;###autoload
(defun unpackaged/org-return-dwim (&optional default)
  "A helpful replacement for `org-return'.  With prefix, call `org-return'.

On headings, move point to position after entry content.  In
lists, insert a new item or end the list, with checkbox if
appropriate.  In tables, insert a new row or end the table."
  ;; Inspired by John Kitchin: http://kitchingroup.cheme.cmu.edu/blog/2017/04/09/A-better-return-in-org-mode/
  (interactive "P")
  (if default
      (org-return)
    (cond
     ;; Act depending on context around point.

     ;; NOTE: I prefer RET to not follow links, but by uncommenting this block, links will be
     ;; followed.

     ;; ((eq 'link (car (org-element-context)))
     ;;  ;; Link: Open it.
     ;;  (org-open-at-point-global))

     ((org-at-heading-p)
      ;; Heading: Move to position after entry content.
      ;; NOTE: This is probably the most interesting feature of this function.
      (let ((heading-start (org-entry-beginning-position)))
        (goto-char (org-entry-end-position))
        (cond ((and (org-at-heading-p)
                    (= heading-start (org-entry-beginning-position)))
               ;; Entry ends on its heading; add newline after
               (end-of-line)
               (insert "\n\n"))
              (t
               ;; Entry ends after its heading; back up
               (forward-line -1)
               (end-of-line)
               (when (org-at-heading-p)
                 ;; At the same heading
                 (forward-line)
                 (insert "\n")
                 (forward-line -1))
               ;; FIXME: looking-back is supposed to be called with more arguments.
               (while (not (looking-back (rx (repeat 3 (seq (optional blank) "\n")))))
                 (insert "\n"))
               (forward-line -1)))))

     ((org-at-item-checkbox-p)
      ;; Checkbox: Insert new item with checkbox.
      (org-insert-todo-heading nil))

     ((org-in-item-p)
      ;; Plain list.  Yes, this gets a little complicated...
      (let ((context (org-element-context)))
        (if (or (eq 'plain-list (car context))  ; First item in list
                (and (eq 'item (car context))
                     (not (eq (org-element-property :contents-begin context)
                              (org-element-property :contents-end context))))
                (unpackaged/org-element-descendant-of 'item context))  ; Element in list item, e.g. a link
            ;; Non-empty item: Add new item.
            (org-insert-item)
          ;; Empty item: Close the list.
          ;; TODO: Do this with org functions rather than operating on the text. Can't seem to find the right function.
          (delete-region (line-beginning-position) (line-end-position))
          (insert "\n"))))

     ((when (fboundp 'org-inlinetask-in-task-p)
        (org-inlinetask-in-task-p))
      ;; Inline task: Don't insert a new heading.
      (org-return))

     ((org-at-table-p)
      (cond ((save-excursion
               (beginning-of-line)
               ;; See `org-table-next-field'.
               (cl-loop with end = (line-end-position)
                        for cell = (org-element-table-cell-parser)
                        always (equal (org-element-property :contents-begin cell)
                                      (org-element-property :contents-end cell))
                        while (re-search-forward "|" end t)))
             ;; Empty row: end the table.
             (delete-region (line-beginning-position) (line-end-position))
             (org-return))
            (t
             ;; Non-empty row: call `org-return'.
             (org-return))))
     (t
      ;; All other cases: call `org-return'.
      (org-return)))))

1
2
3
4
5
6
7
8

;;;###autoload
(defun unpackaged/org-sort-multi ()
  "Call `org-sort' until \\[keyboard-quit] is pressed."
  (interactive)
  ;; Not sure if `with-local-quit' is necessary, but probably a good
  ;; idea in case of recursive edit.
  (with-local-quit
    (cl-loop while (call-interactively #'org-sort))))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

(setq user-full-name "GTrunSec"
      user-mail-address "gtrunsec@hardenedlinux.org")
;; (setq auth-sources '("~/.authinfo.gpg")
;;       auth-source-cache-expiry nil) ; default is 7200 (2h)

(setq-default history-length 1000)
(setq create-lockfiles nil)
(require 'org-protocol)

;; (setq browse-url-browser-function 'browse-url-Chrome)
;; https://emacs.stackexchange.com/questions/5603/how-to-quickly-copy-move-file-in-emacs-dired
(setq dired-dwim-target t)

(add-hook! 'dired-mode 'dired-async-mode)

(defun gtrun/truncate-lines-hook ()
  (setq-local truncate-lines nil)
  )

(add-hook! 'text-mode-hook 'gtrun/truncate-lines-hook)

(setenv "XAPIAN_CJK_NGRAM" "1")
(setenv "QT_DEBUG_PLUGINS" "1")
(fset 'yes-or-no-p 'y-or-n-p)

(setq plantuml-jar-path (expand-file-name "~/.myscript/plantuml"))

1
2
3
4
5

(setq-default
 delete-by-moving-to-trash t                      ;; Delete files to trash
 window-combination-resize t                      ;; take new window space from all other windows (not just current)
 x-stretch-cursor t)                              ;; Stretch cursor to the glyph width

1

t

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

  (use-package! counsel
    :hook
    (after-init . ivy-mode)
    (counsel-grep-post-action . better-jumper-set-jump)
    :diminish ivy-mode
    :config
    (setq counsel-find-file-ignore-regexp "\\(?:^[#.]\\)\\|\\(?:[#~]$\\)\\|\\(?:^Icon?\\)"
          counsel-describe-function-function #'helpful-callable
          ncounsel-describe-variable-function #'helpful-variable
          ;; Add smart-casing (-S) to default command arguments:
          counsel-rg-base-command "rg -S --no-heading --line-number --color never %s ."
          counsel-ag-base-command "ag -S --nocolor --nogroup %s"
          counsel-pt-base-command "pt -S --nocolor --nogroup -e %s"
          counsel-find-file-at-point t)
       )

     (use-package! ivy-rich
       :config
       (ivy-rich-mode 1)
       (setq ivy-format-function #'ivy-format-function-line))
     ;;[[https://github.com/gilbertw1/better-jumper][gilbertw1/better-jumper: A configurable jump list implementation for Emacs]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

(after! company
  (setq company-idle-delay 0.5
        company-minimum-prefix-length 2
        company-transformers nil)
  (setq company-show-numbers t)
  (define-key company-active-map (kbd "C-n") 'company-select-next-or-abort)
  (define-key company-active-map (kbd "C-j") 'company-select-previous-or-abort)

  (defun ora-company-number ()
  "Forward to `company-complete-number'.
Unless the number is potentially part of the candidate.
In that case, insert the number."
  (interactive)
  (let* ((k (this-command-keys))
         (re (concat "^" company-prefix k)))
    (if (or (cl-find-if (lambda (s) (string-match re s))
                        company-candidates)
            (> (string-to-number k)
               (length company-candidates))
            (looking-back "[0-9]+\\.[0-9]*" (line-beginning-position)))
        (self-insert-command 1)
      (company-complete-number
       (if (equal k "0")
           10
         (string-to-number k))))))

(defun ora--company-good-prefix-p (orig-fn prefix)
  (unless (and (stringp prefix) (string-match-p "\\`[0-9]+\\'" prefix))
    (funcall orig-fn prefix)))
(advice-add 'company--good-prefix-p :around #'ora--company-good-prefix-p)

(let ((map company-active-map))
  (mapc (lambda (x) (define-key map (format "%d" x) 'ora-company-number))
        (number-sequence 0 9))
  (define-key map " " (lambda ()
                        (interactive)
                        (company-abort)
                        (self-insert-command 1)))
  (define-key map (kbd "<return>") nil)))

1
2

;; (package! selectrum)
;; (package! selectrum-prescient)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

;; (use-package! selectrum
;;   :config
;;   (selectrum-mode +1)
;;   )
;; (use-package! selectrum-prescient
;;   :config
;;   ;; to make sorting and filtering more intelligent
;;   (selectrum-prescient-mode +1)
;;   ;; to save your command history on disk, so the sorting gets more
;;   ;; intelligent over time
;;   ;;(prescient-persist-mode +1)
;;   )

1
2
3

;; First try to indent the current line, and if the line
;; was already indented, then try `completion-at-point'
(setq tab-always-indent 'complete)

1

(package! company-tabnine)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

(use-package! company-tabnine
  :when (featurep! :completion company)
  :config
  (setq company-tabnine--disable-next-transform nil)
  (defun my-company--transform-candidates (func &rest args)
    (if (not company-tabnine--disable-next-transform)
        (apply func args)
      (setq company-tabnine--disable-next-transform nil)
      (car args)))

  (defun my-company-tabnine (func &rest args)
    (when (eq (car args) 'candidates)
      (setq company-tabnine--disable-next-transform t))
    (apply func args))

  (advice-add #'company--transform-candidates :around #'my-company--transform-candidates)
  (advice-add #'company-tabnine :around #'my-company-tabnine)
  ;; Trigger completion immediately.
  ;; (setq company-idle-delay 0)

  ;; Number the candidates (use M-1, M-2 etc to select completions).
  (setq company-show-numbers t)

  ;; Use the tab-and-go frontend.
  ;; Allows TAB to select and complete at the same time.
  (company-tng-configure-default)
  (setq company-frontends
        '(company-tng-frontend
          company-pseudo-tooltip-frontend
          company-echo-metadata-frontend))
  )

1
2
3
4
5
6
7

(use-package! company-math
  :config
  (defun my-latex-mode-setup ()
  (setq-local company-backends
              (append '((company-math-symbols-latex company-latex-commands))
                      company-backends)))
  )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

(set-company-backend! '(julia-mode
                        org-mode)
  '(
    company-math-symbols-unicode
    company-files
    company-yasnippet
    :separate
    company-tabnine
    ))
;;  (set-company-backend! 'sh-mode nil) ; unsets backends for sh-mode
(set-company-backend! '(c-mode
                        c++-mode
                        ess-mode
                        haskell-mode
                        ;;emacs-lisp-mode
                        conf-mode
                        lisp-mode
                        sh-mode
                        php-mode
                        python-mode
                        go-mode
                        ruby-mode
                        rust-mode
                        js-mode
                        css-mode
                        web-mode
                        nix-mode
                        json-mode
                        )
  '(
    company-files
    company-yasnippet
    :separate
    company-tabnine
    ))

(setq +lsp-company-backends '(company-capf
                              company-files
                              company-yasnippet
                              :separate
                              company-tabnine
                              ))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

  (use-package! maple-iedit
    :commands (maple-iedit-match-all maple-iedit-match-next maple-iedit-match-previous)
    :config
    (delete-selection-mode t)
    (setq maple-iedit-ignore-case t)
    (defhydra maple/iedit ()
      ("n" maple-iedit-match-next "next")
      ("t" maple-iedit-skip-and-match-next "skip and next")
      ("T" maple-iedit-skip-and-match-previous "skip and previous")
      ("p" maple-iedit-match-previous "prev"))
    :bind (:map maple-iedit-mode-keymap
                ("C-n" . maple-iedit-match-next)
                ("C-m" . maple-iedit-match-previous)
                ("<down>" . maple-iedit-match-next)
                ("<up>" . maple-iedit-match-previous)
                ("C-," . maple-iedit-skip-and-match-next)
                ("C-." . maple-iedit-skip-and-match-previous)
                ("<right>" . maple-iedit-skip-and-match-next)
                ("<left>" . maple-iedit-skip-and-match-previous)
                )
    )

1
2
3
4
5
6
7
8

(use-package! highlight-indent-guides
:config
(setq highlight-indent-guides-method 'character)
(setq highlight-indent-guides-auto-enabled nil)
(set-face-background 'highlight-indent-guides-even-face "dimgray")
(set-face-foreground 'highlight-indent-guides-character-face "dimgray")
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

;;; -*- lexical-binding: t; -*-
;; we will call `blink-matching-open` ourselves...

(remove-hook 'post-self-insert-hook
             #'blink-paren-post-self-insert-function)
;; this still needs to be set for `blink-matching-open` to work
(setq blink-matching-paren 'show)

(let ((ov nil)) ; keep track of the overlay
  (advice-add
   #'show-paren-function
   :after
    (defun show-paren--off-screen+ (&rest _args)
      "Display matching line for off-screen paren."
      (when (overlayp ov)
        (delete-overlay ov))
      ;; check if it's appropriate to show match info,
      ;; see `blink-paren-post-self-insert-function'
      (when (and (overlay-buffer show-paren--overlay)
                 (not (or cursor-in-echo-area
                          executing-kbd-macro
                          noninteractive
                          (minibufferp)
                          this-command))
                 (and (not (bobp))
                      (memq (char-syntax (char-before)) '(?\) ?\$)))
                 (= 1 (logand 1 (- (point)
                                   (save-excursion
                                     (forward-char -1)
                                     (skip-syntax-backward "/\\")
                                     (point))))))
        ;; rebind `minibuffer-message' called by
        ;; `blink-matching-open' to handle the overlay display
        (cl-letf (((symbol-function #'minibuffer-message)
                   (lambda (msg &rest args)
                     (let ((msg (apply #'format-message msg args)))
                       (setq ov (display-line-overlay+
                                 (window-start) msg ))))))
          (blink-matching-open))))))

(defun display-line-overlay+ (pos str &optional face)
  "Display line at POS as STR with FACE.

FACE defaults to inheriting from default and highlight."
  (let ((ol (save-excursion
              (goto-char pos)
              (make-overlay (line-beginning-position)
                            (line-end-position)))))
    (overlay-put ol 'display str)
    (overlay-put ol 'face
                 (or face '(:inherit default :inherit highlight)))
    ol))

(setq show-paren-style 'paren
      show-paren-delay 0.03
      show-paren-highlight-openparen t
      show-paren-when-point-inside-paren nil
      show-paren-when-point-in-periphery t)
(show-paren-mode 1)

1

(use-package! awesome-pair)

1

(package! hungry-delete)

1
2
3
4

(use-package! hungry-delete
  :config
  (add-hook! 'after-init-hook #'global-hungry-delete-mode)
)

1

(package! format-all :recipe (:host github :repo "lassik/emacs-format-all-the-code"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

(use-package! format-all
  :config
  (dolist (hook (list
                 'js-mode-hook
                 'rust-mode-hook
                 'python-mode-hook
                 'java-mode-hook
                 'sh-mode-hook
                 'nix-mode-hook
                 'haskell-mode-hook
                 'emacs-lisp-mode-hook
                 ))
    (add-hook hook 'format-all-mode))
  (add-hook! 'format-all-mode-hook 'format-all-ensure-formatter)
  )

1

t

1

(package! bm)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

  (use-package! bm
    :demand t
    :init
    (setq bm-restore-repository-on-load t)
    :config

    (bind-keys
     :map bm-show-mode-map
     ("j" . next-line)
     ("k" . previous-line))

    (setq bm-cycle-all-buffers t
          bm-highlight-style 'bm-highlight-only-fringe
          bm-repository-size 1000)
    (setq-default bm-buffer-persistence t)

    (defun adq/bm-save ()
      "Save bookmarks to persistent repository."
      (interactive)
      (bm-buffer-save-all)
      (bm-repository-save))

    (advice-add 'bm-bookmark-add
                :after (lambda (&rest args)
                         (adq/bm-save)))
    (advice-add 'bm-bookmark-remove
                :after (lambda (&rest args)
                         (adq/bm-save)))
    (add-hook 'after-init-hook #'bm-repository-load)
    (add-hook 'find-file-hooks #'bm-buffer-restore)
    (add-hook 'after-rever-hook #'bm-buffer-restore)
    (add-hook 'kill-buffer-hook #'bm-buffer-save)
    (add-hook 'after-save-hook #'bm-buffer-save)
    (add-hook 'kill-emacs-hook
              (lambda ()
                (bm-buffer-save-all)
                (bm-repository-save)))

    (defun adq/bm-list-all-bookmarks ()
      "Generate a list of all bookmarks from all files."
      (let ((bookmarks '()))
        (cl-loop for entry in bm-repository
                 when (and (listp entry) (f-readable-p (car entry)))
                 do
                 (with-temp-buffer
                   (insert-file-contents-literally (car entry))
                   (cl-letf (((symbol-function 'bm-bookmark-add)
                              (lambda (&optional annotation time temporary)
                                (!cons (list (car entry)
                                             (point)
                                             (line-number-at-pos)
                                             (string-trim (thing-at-point 'line t)))
                                       bookmarks)))
                             ((symbol-function 'message)
                              (lambda (&rest _))))
                     (bm-buffer-restore-2 (cdr entry)))))
        bookmarks))

      (defun adq/helm-bm-all-format-bookmark (bookmark)
        "Format bookmark for display."
        (let ((file (f-filename (car bookmark)))
              (line (caddr bookmark))
              (contents (cadddr bookmark)))
          (cons
           (format "%s:%s: %s"
                   (propertize file 'face compilation-info-face)
                   (propertize (format "%d" line) 'face compilation-line-face)
                   contents)
           bookmark)))

      (defvar adq/helm-bm-all-source
        (helm-build-sync-source "Helm All Bookmarks"
          :candidates
          (lambda ()
            (mapcar #'adq/helm-bm-all-format-bookmark
                    (adq/bm-list-all-bookmarks)))
          :action
          '(("Switch to buffer" .
             (lambda (bookmark)
               (find-file (car bookmark))
               (goto-char (cadr bookmark))))))
        "Helm source with all the bookmarks.")

      (defun adq/helm-bm-list-all ()
        "List all bookmarks usin Helm."
        (interactive)
        (helm :sources 'adq/helm-bm-all-source
              :buffer "*helm bm all*"))

    (defhydra adq/hydra-bm nil
      "
  Bookmarks
  ^^^^------------------------------------------------
  _m_: Toggle      _l_: Bookmarks from Buffers
  _n_: Next        _a_: Bookmarks form All Files
  _p_: Previous    _L_: List
  "
      ("m" bm-toggle)
      ("n" bm-next)
      ("p" bm-previous)
      ("a" adq/helm-bm-list-all :exit t)
      ("l" helm-bm :exit t)
      ("L" bm-show-all :exit t))
    (bind-key "C-c m" #'adq/hydra-bm/body))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

;; (use-package! fast-scroll
;; :config
;; (setq fast-scroll-throttle 0.5)
;; (add-hook 'fast-scroll-start-hook (lambda () (flycheck-mode -1)))
;; (add-hook 'fast-scroll-end-hook (lambda () (flycheck-mode 1)))
;; (fast-scroll-config)
;; (fast-scroll-mode 1)
;; )
(use-package! scrollkeeper)
(global-set-key [remap scroll-up-command] #'scrollkeeper-contents-up)
(global-set-key [remap scroll-down-command] #'scrollkeeper-contents-down)

1

(package! yatemplate)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

(use-package! yatemplate
  :after yasnippet
  :config
  ;; Define template directory
  (setq yatemplate-dir (concat doom-private-dir "modules/templates"))
  ;; Coupling with auto-insert
  (setq auto-insert-alist nil)
  (yatemplate-fill-alist)
  (add-hook 'find-file-hook 'auto-insert)
  )

1
2
3

(load! "setting")
(use-package! ox-hugo)
(use-package! ob-session-async)

1
2
3
4
5

(define-derived-mode only-file-to-org-mode org-mode "Org + only mode"
  "Only modes for org file."
  (add-hook! org-tanglesync-watch-mode :local #'org-tanglesync-mode)
  )
(add-to-list 'auto-mode-alist '("README-[^z-a]*\\.org\\'" . only-file-to-org-mode))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

(after! org
  (when IS-LINUX
    (setq org-id-locations-file (concat org-directory "/cache/.linux-orgids"))
    )

  (when IS-MAC
    (setq org-id-locations-file (concat org-directory "/cache/.mac-orgids"))
    )

  (setq org-clock-into-drawer t)
  (add-hook! 'org-mode-hook 'auto-revert-mode)
  (add-hook! 'dired-mode-hook 'org-download-enable)
  ;; (setq-hook! 'org-mode-hook fill-column 80)
  ;; (setq-hook! 'org-mode-hook org-superstar-mode 1)
  (setq org-directory "~/Documents/org-notes")
  (setq org-log-into-drawer t)
  (setq org-agenda-start-day "-1d")
  (setq org-agenda-span 2)
  (setq org-time-clocksum-format '(:hours "%d" :require-hours t :minutes ":%02d" :require-minutes t))
  (setq org-archive-location (concat "%s_archive_" (format-time-string "%Y" (current-time)) "::"))
  ;; Removes clocked tasks with 0:00 duration
  (setq org-clock-out-remove-zero-time-clocks t)
  ;; Change task state to STARTED when clocking in
  (setq org-clock-in-switch-to-state "⚔ INPROCESS")
  (setq org-src-fontify-natively t
        org-src-preserve-indentation t
        org-src-tab-acts-natively t
        org-src-window-setup 'current-window)
  (setq org-agenda-time-leading-zero t)

  ;;Markdown
  (eval-after-load "org"
    '(require 'ox-md nil t))
  ;;https://orgmode.org/worg/org-contrib/babel/examples/fontify-src-code-blocks.html

  (defun org-show-two-levels ()
    (interactive)
    (org-content 2))

  (setq org-download-timestamp "%Y%m%d_%H%M%S")

  (add-hook! 'org-mode-hook 'org-show-two-levels)
  (add-hook! 'after-init-hook 'org-id-update-id-locations)

  (add-hook! 'unpackaged/org-return-dwim 'unpackaged/org-fix-blank-lines)
  (define-key org-mode-map (kbd "C-c ;") 'org-time-stamp-inactive)
  (define-key org-mode-map (kbd "RET") 'unpackaged/org-return-dwim)
  (setq org-plantuml-jar-path (expand-file-name "~/.myscript/plantuml"))
  )

1

(package! org-starter)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

(use-package! org-starter
  :custom
  ;; Enable external configuration files loaded from org-starter-path
  (org-starter-load-config-files t)
  :config
  (org-starter-def "~/Documents/org-notes"
    :files
    ("posts/myself/love.org"         :key "l" :refile (:maxlevel . 5 ))
    ("posts/myself/qing.org"         :key "q" :refile (:maxlevel . 5 ))
    ("posts/myself/plan.org"         :key "p" :refile (:maxlevel . 5 ))
    )
  (org-starter-def "~/Documents/org-notes/braindump"
    :files
    ("myself-private/" :agenda t)
    ("myself-private/GTD/gtd.org"                      :key "g" :refile (:maxlevel . 5))
    ("myself-private/GTD/notes.org"                    :key "n" :refile (:maxlevel . 5 ))
    ("myself-private/GTD/myself.org"                    :key "m" :refile (:maxlevel . 5 ))
    ("myself-private/GTD/Habit.org"                     :key "h" :refile (:maxlevel . 5 ))
    ;;
    ("guangtao/" :agenda t)
    ("guangtao/learn_music.org"          :agenda t :key "M" :refile (:maxlevel . 5 ))
    ("guangtao/guangtao's_library.org"       :key "b" :refile (:maxlevel . 5 ))
    ("guangtao/guangtao's_feed.org"         :agenda t :key "f" :refile (:maxlevel . 5 ))
    ;;
    ("life/" :agenda t)
    ("life/life_goods.org"     :key "s" :refile (:maxlevel . 5 ))
    ("gaming/" :agenda t)
    ("journals/" :agenda t)
    ("hardware/" :agenda t)
    ("system/" :agenda t)
    ("deployment/" :agenda t)
    ("cs/" :agenda t)
    ("programming/" :agenda t)
    ("nix/" :agenda t)
    ("emacs/" :agenda t)
    ("security/" :agenda t)
    ("financial/" :agenda t)
    ("network/" :agenda t)
    ("data-science/" :agenda t)
    )
  (org-starter-def "~/.config/nixpkgs/dotfiles/doom-emacs/"
    :files
    ("config.org" :key "c" :refile (:maxlevel . 5))
    ("meow.org" :key "w" :refile (:maxlevel . 5))
    )
  (org-starter-def "~/.config/nixpkgs"
    :files
    ("README.org")
    ("global-readme.org")
    ("dotfiles/wallpaper/wallpaper.org" :agenda nil)
    )

  (defhydra gtrun/hydra-org-starter nil
    "
  Org-starter-files
  ^^^^------------------------------------------------
 _c_: config.org  _g_: gtd.org     _l_: love.org
 _n_: note        _h_: Habit.org    _w_: meow.org
 _m_: myself      _p_: Plan.org
 _b_: my-books    _f_: feed
 _s_: life-goods
  "

    ("c" org-starter-find-file:config)
    ("w" org-starter-find-file:meow)
    ("g" org-starter-find-file:gtd)
    ("s" org-starter-find-file:life_goods)
    ("n" org-starter-find-file:notes)
    ("f" org-starter-find-file:feed)
    ("m" org-starter-find-file:myself)
    ("l" org-starter-find-file:love)
    ("h" org-starter-find-file:Habit)
    ("p" org-starter-find-file:plan)
    ("b" org-starter-find-file:guangtao\'\s_library)
    )
  :commands org-starter-load-all-files-in-path
  :hook
  (after-init . org-starter-load-all-files-in-path)
  :bind
  (
   ("C-c e" . org-starter-select-file))
  ;; "C-c e" . org-starter-refile-by-key))
  )

1

org-starter-select-file

1

(package! org-superstar)

1
2
3
4
5
6

(use-package! org-superstar
  :hook
  (org-mode . org-superstar-mode)
  :config
  (setq org-superstar-headline-bullets-list '("☰" "☷" "☵" "☲"  "☳" "☴"  "☶"  "☱" ))
)

1
2
3

(package! org-ql :recipe (:host github :repo "alphapapa/org-ql"
                         :files ("*.el")
                         ))

1

(use-package! org-ql)

1

(package! helm-org-rifle)

1

(use-package! helm-org-rifle)

1

(package! org-books :recipe (:host github :repo "lepisma/org-books"))

1
2
3
4

(use-package! org-books
  :config
  (setq org-books-file "~/Documents/org-notes/braindump/guangtao/guangtao's_library.org")
  )

1
2
3

(package! org-z :recipe (:host github :repo "landakram/org-z"
                         :files ("*.el")
                         ))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

(use-package! org-z
  :init
  (define-key org-mode-map (kbd "C-c C-;") 'org-z-insert-link)
  (require 'org-z-helm)
  ;;(require 'org-z-selectrum)
  :config
  (org-z-mode 1)
  (setq org-z-directories  '("~/Documents/org-notes/braindump"
                             "~/Documents/org-notes/braindump/guangtao"
                             "~/Documents/org-notes/braindump/journals"
                             "~/Documents/org-notes/braindump/cs"
                             "~/Documents/org-notes/braindump/network"
                             "~/Documents/org-notes/braindump/security"
                             "~/Documents/org-notes/braindump/life"
                             "~/Documents/org-notes/braindump/math"
                             "~/Documents/org-notes/braindump/math/my-mathematic-julia"
                             "~/Documents/org-notes/braindump/data-science"
                             "~/Documents/org-notes/braindump/deployment"
                             "~/Documents/org-notes/braindump/hardware"
                             "~/Documents/org-notes/braindump/system"
                             "~/Documents/org-notes/braindump/emacs"
                             "~/Documents/org-notes/braindump/gaming"
                             "~/Documents/org-notes/braindump/financial"
                             "~/Documents/org-notes/braindump/myself-private"
                             "~/Documents/org-notes/braindump/myself-private/GTD"
                             "~/Documents/org-notes/braindump/nix"
                             "~/Documents/org-notes/braindump/programming"
                             "~/.config/nixpkgs/dotfiles/doom-emacs"
                             ))

   )

1

t

1

(package! org-super-agenda)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

(use-package! org-super-agenda
  :config
  (add-hook! 'after-init-hook 'org-super-agenda-mode)
  (require 'org-habit)
  (setq
   org-agenda-skip-scheduled-if-done t
   org-agenda-skip-deadline-if-done t
   org-agenda-include-deadlines t
   org-agenda-include-diary nil
   org-agenda-block-separator nil
   org-agenda-compact-blocks t
   org-agenda-start-with-log-mode t)
  )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

    (setq org-todo-keywords
     '((sequence
           "TODO(t)"  ; A task that needs doing & is ready to do
           "PROJ(p)"  ; An ongoing project that cannot be completed in one step
           "INPROCESS(s)"  ; A task that is in progress
           "⚑ WAITING(w)"  ; Something is holding up this task; or it is paused
           "|"
           "☟ NEXT(n)"
           "✰ IMPORTANT(i)"
           "DONE(d)"  ; Task successfully completed
           "✘ CANCELED(c@)") ; Task was cancelled, aborted or is no longer applicable
          (sequence
           "✍ NOTE(N)"
           "FIXME(f)"
           "☕ BREAK(b)"
           "❤ LOVE(l)"
           "REVIEW(r)"
           )) ; Task was completed
        org-todo-keyword-faces
        '(
          ("TODO" . (:foreground "#ff39a3" :weight bold))
          ("INPROCESS"  . "orangered")
          ("✘ CANCELED" . (:foreground "white" :background "#4d4d4d" :weight bold))
          ("⚑ WAITING" . "pink")
          ("☕ BREAK" . "gray")
          ("❤ LOVE" . (:foreground "VioletRed4"
                                   ;; :background "#7A586A"
                                   :weight bold))
          ("☟ NEXT" . (:foreground "DeepSkyBlue"
                                   ;; :background "#7A586A"
                                      :weight bold))
          ("✰ IMPORTANT" . (:foreground "greenyellow"
                                      ;; :background "#7A586A"
                                      :weight bold))
          ("DONE" . "#008080")
          ("FIXME" . "IndianRed")
          ))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

(require 'org-super-agenda)
(setq org-agenda-custom-commands
      '(("z" "GtruN Agenda"
         ((agenda "" ((org-agenda-span 2)
                      (org-agenda-start-day "-1d")
                      (org-super-agenda-groups
                       '((:name "Today List"
                                :time-grid t
                                :date today
                                :todo "⚔ INPROCESS"
                                :scheduled today
                                :order 1)))))
          (alltodo "" ((org-agenda-overriding-header "")
                       (org-super-agenda-groups
                        '((:name "Next to do"
                                 :priority>= "B"
                                 :order 2)
                          (:name "Important"
                                 :todo "✰ Important"
                                 :order 6)
                          (:name "Due Today"
                                 :deadline today
                                 :order 3)
                          (:name "Due Soon"
                                 :deadline future
                                 :order 8)
                          (:name "Overdue"
                                 :deadline past
                                 :order 20)
                          (:name "Issues"
                                 :tag "Issue"
                                 :order 12)
                          (:name "Projects"
                                 :tag "Project"
                                 :order 14)
                          (:name "Emacs"
                                 :tag "Emacs"
                                 :order 13)
                          (:name "Research"
                                 :tag "Research"
                                 :order 15)
                          (:name "To read"
                                 :tag ("BOOK" "READ")
                                 :order 30)
                          (:name "Waiting"
                                 :todo "⚑ WAITING"
                                 :order 18)
                          (:name "trivial"
                                 :priority<= "C"
                                 :todo ("SOMEDAY")
                                 :order 90)
                          (:discard (:tag ("Chore" "Routine" "Daily")))))))))

        ("b" . "BOOK")

        ("bb" "Search tags in todo, note, and archives"
         search "+{:book\\|books:}")

        ("bd" "BOOK TODO List"
         search "+{^\\*+\\s-+\\(⚔ INPROCESS\\|TODO\\|⚑ WAITING\\)\\s-} +{:book\\|books:}")

        ("d" "ALL DONE OF TASKS"
         search "+{^\\*+\\s-+\\(✔ DONE\\|✘ CANCELED\\)\\s-}")

        ("i" "ALL INPROCESS OF TASKS"
         search "+{^\\*+\\s-+\\(⚔ INPROCESS\\)\\s-}")

        ))

1

(package! org-edna :recipe (:build (:not compile)))

1
2
3
4

(use-package! org-edna
  :config
  (add-hook! 'after-init-hook 'org-edna-mode)
)

1

(package! org-wild-notifier)

1
2
3
4
5
6

(use-package! org-wild-notifier
  :defer t
  :config
  (add-hook! 'after-init-hook 'org-wild-notifier-mode)
  (setq ;;org-wild-notifier-alert-time 15
        alert-default-style (if IS-MAC 'osx-notifier 'libnotify)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

(after! ob-async
  (setq ob-async-no-async-languages-alist '("ipython" "ein-python"
                                            "ein-rust"
                                            "ein-julia"
                                            "ein-haskell"
                                            ))
  )

;;[[https://stackoverflow.com/questions/22668112/how-to-evaluate-all-code-blocks-when-exporting-in-emacs-org-mode][How to evaluate all code blocks when exporting in emacs org-mode - Stack Overflow]]
(setq org-confirm-babel-evaluate nil)
(setq org-export-use-babel nil)

(setq org-babel-C++-compiler 'clang++)
(setq org-babel-C-compiler 'clang)

1

gcc-9

1
2
3
4
5
6
7
8
9

;;; setting.el -*- lexical-binding: t; -*-
(setq org-publish-project-alist
      '(
        ("init"
         :base-directory "~/.config/nixpkgs/dotfiles/doom-emacs"
         :publishing-function org-html-publish-to-html
         :publishing-directory "~/Documents/my-blog/public/custom"
         )
        ))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

;; 當被加密的部份要存入硬碟時，自動加密回去
  ;; 設定要加密的 tag 標籤為 secret
  (setq org-crypt-tag-matcher "secret")

  ;; 避免 secret 這個 tag 被子項目繼承 造成重複加密
  ;; (但是子項目還是會被加密喔)
  (setq org-tags-exclude-from-inheritance (quote ("secret")))

  ;; 用於加密的 GPG 金鑰
  ;; 可以設定任何 ID 或是設成 nil 來使用對稱式加密 (symmetric encryption)
  (setq org-crypt-key nil)

1

(package! notdeft :recipe (:host github :repo "hasu/notdeft"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

(use-package! notdeft
  :config
  (setq notdeft-extension "org")
  ;;(setq notdeft-secondary-extensions '("md" "org" "scrbl"))
  (setq notdeft-xapian-program "/home/gtrun/.nix-profile/bin/notdeft-xapian")
  (when IS-MAC
    (setq notdeft-xapian-program "/Users/gtrun/.nix-profile/bin/notdeft-xapian")
    )
  (setq notdeft-directories '("~/Documents/org-notes/post/myself"
                              "~/Documents/org-notes/dailies"
                              "~/Documents/org-notes/post/traveling"
                              "~/Documents/org-notes/post/agenda"
                              "~/Documents/org-notes/post/game"
                              "~/Dropbox/project/my-learning-list"
                              "~/Documents/org-notes/GTD"
                              "~/Documents/org-notes/art"
                              "~/Documents/org-notes/braindump"
                              ))

  :bind (:map notdeft-mode-map
         ("C-q" . notdeft-quit)
         ("C-r" . notdeft-refresh)
         )
  )

1

(setq org-export-with-broken-links t)

1

t

1

(unpin! org-roam)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

(use-package! org-roam
  :init
  (require 'org-roam-protocol)
  :config
  (setq org-roam-index-file "~/Documents/org-notes/braindump/pages/contents.org")
  ;;https://github.com/zaeph/.emacs.d/blob/0f4bf9a500ef6397b93c41cb51602bea9ab9a4c3/init.el#L3804
  ;; [[https://copingmechanism.com/2020/keeping-org-roam-daily-notes-in-a-separate-folder/][Keeping Org-roam Daily Notes in a separate folder – Coping Mechanism]]
  ;; (setq org-roam-dailies-capture-templates '(("d" "daily" plain (function org-roam-capture--get-point) ""
  ;;                                             :immediate-finish t
  ;;                                             :file-name "dailies/%<%Y-%m-%d>-${slug}"
  ;;                                             :head "#+TITLE: %<%Y-%m-%d>-${slug}\n#+created: %u\n#+last_modified: %U\n\n")))
  )

1

;;(package! org-roam-server)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

;; (use-package! org-roam-server
;;   :config
;;   (setq org-roam-server-port 8081
;;         org-roam-server-export-inline-images t
;;         org-roam-server-authenticate nil
;;         org-roam-server-network-poll t
;;         org-roam-server-network-arrows nil
;;         org-roam-server-network-label-truncate t
;;         org-roam-server-network-label-truncate-length 60
;;         org-roam-server-network-label-wrap-length 20))

1

;;(package! org-roam-bibtex)

1
2
3
4
5
6
7

;; (use-package! org-roam-bibtex
;;   :config
;;   (add-hook 'org-mode-hook 'org-roam-bibtex-mode)
;;   :bind (:map org-roam-bibtex-mode-map
;;               ("C-c n a" . orb-note-actions)
;;               )
;;   )

1

(package! nroam :recipe (:host github :repo "NicolasPetton/nroam"))

1
2
3
4

(use-package! nroam
  :after org-roam
  :config
  (add-hook 'org-mode-hook #'nroam-setup-maybe))

1

(package! org-ref)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

(use-package! org-ref
  :config
  (defsubst dnd-unescape-uri (uri)
  (replace-regexp-in-string
   "%[A-Fa-f0-9][A-Fa-f0-9]"
   (lambda (arg)
     (let ((str (make-string 1 0)))
       (aset str 0 (string-to-number (substring arg 1) 16))
       str))
   uri t t))
  (setq org-ref-default-bibliography '("~/Documents/org-notes/braindump/bibliography/myBibliography.bib"))
  (setq bibtex-completion-bibliography "~/Documents/org-notes/braindump/bibliography/myBibliography.bib")
  )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

;; (defun org-roam-dailies-capture-today ()
;;   "Capture a note into the daily note for today."
;;   (interactive)
;;   (let ((org-roam-capture-templates org-roam-dailies-capture-templates)
;;         (org-roam-capture--info (list (cons 'time (current-time))))
;;         (org-roam-capture--context 'dailies))
;;     (org-roam--capture)))

;; (setq org-capture-templates '(("n" "Note" entry (function org-roam-dailies-capture-today)
;;                                  "* %?\n")))

1
2
3
4
5
6

(use-package! org-journal
  :config
  (setq org-journal-dir "~/Documents/org-notes/braindump/journals")
  (setq org-journal-file-format "%Y_%m_%d.org")
  )

1

;;(package! gkroam :recipe (:host github :repo "Kinneyzhang/gkroam"))

1
2
3
4
5
6
7
8
9

;; (use-package gkroam
;;   :hook (after-init . gkroam-mode)
;;   :init
;;   (setq gkroam-root-dir "~/Documents/org-notes/braindump")
;;   (setq gkroam-prettify-page-p t
;;         gkroam-show-brackets-p nil
;;         gkroam-use-default-filename t
;;         gkroam-window-margin 4)
;;   )

1

(package! org-brain :recipe (:build (:not compile)))

1
2
3
4
5
6
7
8

(use-package! org-brain
  :config
  (setq org-brain-visualize-default-choices 'all
        org-brain-title-max-length 24
        org-brain-include-file-entries nil
        org-brain-file-entries-use-title nil)
  (setq org-brain-path "~/Documents/org-notes/braindump")
  )

1

(package! ob-mermaid)

1
2
3
4

(use-package! ob-mermaid
  :config
  (setq ob-mermaid-cli-path "~/.nix-profile/bin/mmdc")
  )

1

(package! org-spacer.el :recipe (:host github :repo "dustinlacewell/org-spacer.el"))

1
2
3
4
5
6

;; (use-package! org-spacer
;;   :config
;;   ;; (add-hook 'org-mode-hook
;;   ;;           (lambda () (add-hook 'before-save-hook
;;   ;;                                'org-spacer-enforce nil 'make-it-local)))
;;   )

1

(package! org-treeusage :recipe (:host github :repo "mtekman/org-treeusage.el"))

1
2
3
4
5