maciej/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Slowly replace use-package with with-eval-after-load

Browse source
This commit is contained in:
Maciej 2024-10-23 11:06:19 +03:00
parent c7b0c1c6c2
commit 1fe168ccc6
Signed by: maciej
GPG key ID: 41D62D42D3B0D765
10 changed files with 360 additions and 377 deletions
Download patch file Download diff file Expand all files Collapse all files

294
elpaca.lock
View file

File diff suppressed because it is too large Load diff

4
lisp/icejam-avy.el
View file

@ -9,13 +9,13 @@
;; Avy is a navigation manager. ;; Avy is a navigation manager.
;;; Code: ;;; Code:
(use-package avy :ensure t) (require 'icejam-keys-mode)
(use-package avy :ensure t)
(with-eval-after-load 'avy (with-eval-after-load 'avy
(setq avy-timeout-seconds 1) (setq avy-timeout-seconds 1)
;; Jump to text in sight with CMD-j ;; Jump to text in sight with CMD-j
(define-key icejam-keys-mode-map [(hyper j)] 'avy-goto-char-timer)) (define-key icejam-keys-mode-map [(hyper j)] 'avy-goto-char-timer))
(provide 'icejam-avy) (provide 'icejam-avy)
;;; icejam-avy.el ends here ;;; icejam-avy.el ends here

48
lisp/icejam-base.el
View file

@ -40,16 +40,17 @@
(global-set-key (kbd "RET") 'newline) (global-set-key (kbd "RET") 'newline)
;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;; ;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;;
(use-package easy-kill :ensure t :defer t (use-package easy-kill :ensure t)
:config (global-set-key [remap kill-ring-save] 'easy-kill)) (with-eval-after-load 'easy-kill
(global-set-key [remap kill-ring-save] 'easy-kill))
;; Move buffers around with buffer keys ;; Move buffers around with buffer keys
(use-package buffer-move :ensure t :defer t) (use-package buffer-move :ensure t :defer t)
;; Garbage collection magic hack ;; Garbage collection magic hack
(use-package gcmh :ensure t (use-package gcmh :ensure t)
:config (gcmh-mode 1) (with-eval-after-load 'gcmh
(gcmh-mode 1)
(setq gcmh-verbose nil (setq gcmh-verbose nil
gcmh-idle-delay 'auto gcmh-idle-delay 'auto
gcmh-auto-idle-delay-factor 10)) gcmh-auto-idle-delay-factor 10))
@ -96,13 +97,17 @@
;; Allow to execute path from shell ;; Allow to execute path from shell
(use-package exec-path-from-shell (use-package exec-path-from-shell
:if (memq window-system '(x mac ns)) :if (memq window-system '(x mac ns))
:ensure t :ensure t)
:config (add-to-list 'exec-path "/usr/local/bin")
(with-eval-after-load 'exec-path-from-shell
(add-to-list 'exec-path "/usr/local/bin")
(dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE")) (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
(add-to-list 'exec-path-from-shell-variables var)) (add-to-list 'exec-path-from-shell-variables var))
(exec-path-from-shell-initialize)) (exec-path-from-shell-initialize))
(use-package direnv :ensure t :config (direnv-mode)) (use-package direnv :ensure t)
(with-eval-after-load 'direnv
(direnv-mode t))
;; Draw underline lower ;; Draw underline lower
(setq x-underline-at-descent-line t) (setq x-underline-at-descent-line t)
@ -114,28 +119,25 @@
indicate-empty-lines nil) indicate-empty-lines nil)
;;;;;;;;;;;;;;;;; Treemacs ;;;;;;;;;;;;;;;;; Treemacs
(use-package treemacs :ensure t :defer t (use-package treemacs :ensure t)
:config (treemacs-follow-mode 1) ;; Follow the current project. (with-eval-after-load 'treemacs
:bind (:map icejam-keys-mode-map (treemacs-follow-mode t)
([(hyper b)] . treemacs))) ;; Show the folder tree (treemacs-project-follow-mode t)
(define-key icejam-keys-mode-map [(hyper b)] 'treemacs))
(use-package treemacs-all-the-icons :defer t :requires (treemacs) :ensure t (use-package treemacs-all-the-icons :ensure t :requires (treemacs))
:config (with-eval-after-load 'treemacs-all-the-icons
(treemacs-load-theme "all-the-icons") (treemacs-load-theme "all-the-icons"))
(treemacs-project-follow-mode t))
;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
(use-package keyfreq (use-package keyfreq :ensure t)
:defer t (with-eval-after-load 'keyfreq
:ensure t
:config
(keyfreq-mode t) (keyfreq-mode t)
(keyfreq-autosave-mode t)) (keyfreq-autosave-mode t))
;;;;;;;;;;;;;;;;; Show hints about key combinations ;;;;;;;;;;;;;;;;; Show hints about key combinations
(use-package which-key (use-package which-key :ensure t)
:ensure t (with-eval-after-load 'which-key
:config
(setq which-key-idle-delay 0.5) (setq which-key-idle-delay 0.5)
(which-key-mode t)) (which-key-mode t))

75
lisp/icejam-company-yasnippet.el
View file

@ -3,49 +3,34 @@
;;; Company completion framework configuration ;;; Company completion framework configuration
;;; Code: ;;; Code:
(use-package yasnippet :ensure t (use-package yasnippet :ensure t)
:config (use-package yasnippet-snippets :ensure t :requires (yasnippet))
(yas-global-mode t)) (use-package company :ensure t :requires (yasnippet yasnippet-snippets))
(use-package company-box :ensure t :requires (company))
(use-package yasnippet-snippets (with-eval-after-load 'yasnippet
:ensure t (yas-global-mode t)
:requires (yasnippet)
:config
(unbind-key "C-c & C-n" yas-minor-mode-map) (unbind-key "C-c & C-n" yas-minor-mode-map)
(unbind-key "C-c & C-s" yas-minor-mode-map) (unbind-key "C-c & C-s" yas-minor-mode-map)
(unbind-key "C-c & C-v" yas-minor-mode-map)) (unbind-key "C-c & C-v" yas-minor-mode-map))
(use-package company
:commands (company-indent-or-complete-common company-yasnippet)
:ensure t
:config (global-company-mode t)
:demand t
:requires (yasnippet
yasnippet-snippets))
(use-package company-box
:ensure t
:defer t
:requires (company)
:hook (company-mode . company-box-mode))
;; (global-company-mode t)
;; Hacks for orderless
(with-eval-after-load 'company (with-eval-after-load 'company
(defun just-one-face (fn &rest args) (global-company-mode t)
;; Hacks for orderless
(defun just-one-face (fn &rest args)
(let ((orderless-match-faces [completions-common-part])) (let ((orderless-match-faces [completions-common-part]))
(apply fn args))) (apply fn args)))
(advice-add 'company-capf--candidates :around #'just-one-face) (advice-add 'company-capf--candidates :around #'just-one-face)
(defun company-completion-styles (capf-fn &rest args) (defun company-completion-styles (capf-fn &rest args)
(let ((completion-styles '(partial-completion basic))) (let ((completion-styles '(partial-completion basic)))
(apply capf-fn args))) (apply capf-fn args)))
(advice-add 'company-capf :around #'company-completion-styles) (advice-add 'company-capf :around #'company-completion-styles)
(setq-default (setq-default
company-minimum-prefix-length 3 ;; minimum prefix character number for auto complete. company-minimum-prefix-length 3 ;; minimum prefix character number for auto complete.
company-idle-delay 0.1 company-idle-delay 0.1
company-require-match nil company-require-match nil
@ -67,8 +52,8 @@
;; company-async-timeout 2 ;; company-async-timeout 2
) )
;; Absolute defaults for company mode ;; Absolute defaults for company mode
(setq company-backends (setq company-backends
'((company-files ; files & directory '((company-files ; files & directory
company-keywords ; keywords company-keywords ; keywords
company-capf company-capf
@ -76,29 +61,31 @@
(company-dabbrev company-abbrev) (company-dabbrev company-abbrev)
)) ))
;; Use standard emacs next and previous bindings for navigating company ;; Use standard emacs next and previous bindings for navigating company
;; suggestions ;; suggestions
(define-key company-active-map (kbd "C-p") 'company-select-previous-or-abort) (define-key company-active-map (kbd "C-p") 'company-select-previous-or-abort)
(define-key company-active-map (kbd "C-n") 'company-select-next-or-abort) (define-key company-active-map (kbd "C-n") 'company-select-next-or-abort)
(defun icejam-insert-space-and-complete () (defun icejam-insert-space-and-complete ()
"Insert space before trying to complete a section." "Insert space before trying to complete a section."
(interactive) (interactive)
(save-excursion (save-excursion
(insert " ")) (insert " "))
(company-indent-or-complete-common)) (company-indent-or-complete-common))
;; Only use RETURN for completion in company ;; Only use RETURN for completion in company
(unbind-key "TAB" company-active-map) (unbind-key "TAB" company-active-map)
;;; Yasnippet configuration ;;; Yasnippet configuration
(define-key prog-mode-map (kbd "C-c y") 'company-yasnippet) (define-key prog-mode-map (kbd "C-c y") 'company-yasnippet)
(define-key prog-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete) (define-key prog-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
(define-key prog-mode-map (kbd "TAB") 'company-indent-or-complete-common) (define-key prog-mode-map (kbd "TAB") 'company-indent-or-complete-common)
(define-key text-mode-map (kbd "C-c y") 'company-yasnippet) (define-key text-mode-map (kbd "C-c y") 'company-yasnippet)
(define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete) (define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
(define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common)) (define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common))
(with-eval-after-load 'company-box (add-hook 'company-mode-hook #'company-box-mode))
(provide 'icejam-company-yasnippet) (provide 'icejam-company-yasnippet)
;;; icejam-company-yasnippet.el ends here ;;; icejam-company-yasnippet.el ends here

65
lisp/icejam-completing-read.el
View file

@ -5,55 +5,54 @@
(require 'icejam-keys-mode) (require 'icejam-keys-mode)
(use-package vertico :ensure t :defer t ;; Preparations for using Vertico/Orderless
:init (setq
(vertico-mode)
:custom
(vertico-scroll-margin 0) ;; Different scroll margin
(vertico-count 15) ;; Show more candidates
(vertico-resize t) ;; Grow and shrink the Vertico minibuffer
(vertico-cycle t) ;; Enable cycling for `vertico-next/previous')
)
;; A few more useful configurations...
(use-package emacs
:custom
;; Support opening new minibuffers from inside existing minibuffers. ;; Support opening new minibuffers from inside existing minibuffers.
(enable-recursive-minibuffers t) enable-recursive-minibuffers t
;; Hide commands in M-x which do not work in the current mode. Vertico ;; Hide commands in M-x which do not work in the current mode. Vertico
;; commands are hidden in normal buffers. This setting is useful beyond ;; commands are hidden in normal buffers. This setting is useful beyond
;; Vertico. ;; Vertico.
(read-extended-command-predicate #'command-completion-default-include-p) read-extended-command-predicate #'command-completion-default-include-p
:init ;; Do not allow the cursor in the minibuffer prompt
;; Add prompt indicator to `completing-read-multiple'. minibuffer-prompt-properties '(read-only t cursor-intangible t face minibuffer-prompt))
;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
(defun crm-indicator (args) (defun crm-indicator (args)
(cons (format "[CRM%s] %s" (cons (format "[CRM%s] %s"
(replace-regexp-in-string (replace-regexp-in-string
"\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" "" "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
crm-separator) crm-separator)
(car args)) (car args))
(cdr args))) (cdr args)))
(advice-add #'completing-read-multiple :filter-args #'crm-indicator) (advice-add #'completing-read-multiple :filter-args #'crm-indicator)
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
;; Do not allow the cursor in the minibuffer prompt ;; Actual orderless
(setq minibuffer-prompt-properties (use-package vertico :ensure t)
'(read-only t cursor-intangible t face minibuffer-prompt)) (use-package orderless :ensure t)
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)) (use-package marginalia :ensure t)
(use-package consult :ensure t)
(use-package helpful :ensure t)
;; Optionally use the `orderless' completion style. (with-eval-after-load 'vertico
(use-package orderless :ensure t :defer t (setq
:custom vertico-scroll-margin 0 ;; Different scroll margin
vertico-count 15 ;; Show more candidates
vertico-resize t ;; Grow and shrink the Vertico minibuffer
vertico-cycle t ;; Enable cycling for `vertico-next/previous'
)
(vertico-mode))
(with-eval-after-load 'orderless
(setq
;; Configure a custom style dispatcher (see the Consult wiki) ;; Configure a custom style dispatcher (see the Consult wiki)
;; (orderless-style-dispatchers '(+orderless-consult-dispatch orderless-affix-dispatch)) ;; (orderless-style-dispatchers '(+orderless-consult-dispatch orderless-affix-dispatch))
;; (orderless-component-separator #'orderless-escapable-split-on-space) ;; (orderless-component-separator #'orderless-escapable-split-on-space)
(completion-styles '(orderless basic)) completion-styles '(orderless basic) ;; Fallback to basic
(completion-category-defaults nil) completion-category-defaults nil
(completion-category-overrides '((file (styles partial-completion))))) completion-category-overrides '((file (styles partial-completion)))))
(use-package marginalia :ensure t :defer t :init (marginalia-mode)) (with-eval-after-load 'marginalia
(use-package consult :ensure t :defer t) (marginalia-mode t))
(use-package helpful :ensure t :defer t)
(with-eval-after-load 'consult (with-eval-after-load 'consult
(define-key icejam-keys-mode-map (kbd "C-c a") 'consult-ripgrep) (define-key icejam-keys-mode-map (kbd "C-c a") 'consult-ripgrep)

39
lisp/icejam-copilot.el
View file

@ -10,15 +10,13 @@
;;; Code: ;;; Code:
(use-package copilot (use-package copilot
:ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el")) :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el")))
:bind (:map copilot-completion-map
("<tab>" . copilot-accept-completion)
("TAB" . copilot-accept-completion)))
;; Do not enable copilot by default because it sorta sucks? (with-eval-after-load 'copilot
;; (add-hook 'prog-mode-hook 'copilot-mode) ;; Do not enable copilot by default because it sorta sucks?
;; (define-key copilot-completion-map (kbd "<tab>") 'copilot-accept-completion) ;; (add-hook 'prog-mode-hook 'copilot-mode)
;; (define-key copilot-completion-map (kbd "TAB") 'copilot-accept-completion) (define-key copilot-completion-map (kbd "<tab>") 'copilot-accept-completion)
(define-key copilot-completion-map (kbd "TAB") 'copilot-accept-completion))
;; Enable Anthropic Claude LLM support for chat (it also sucks) ;; Enable Anthropic Claude LLM support for chat (it also sucks)
(defcustom anthropic-api-key "api-key" "The value of your Anthropic API key." (defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
@ -26,23 +24,26 @@
:group 'icejam :group 'icejam
:initialize 'custom-initialize-set) :initialize 'custom-initialize-set)
(use-package gptel :ensure t (use-package gptel :ensure t)
:config (with-eval-after-load 'gptel
(setq (setq
gptel-model "claude-3-5-sonnet-20240620" gptel-model "claude-3-5-sonnet-20241022"
gptel-backend (gptel-make-anthropic "Claude" gptel-backend (gptel-make-anthropic "Claude"
:stream t :stream t :key (lambda () anthropic-api-key))))
:key (lambda () anthropic-api-key))))
;; Pretend to be 'AI editor'. ;; Pretend to be 'AI editor'.
(use-package elysium :ensure t (use-package elysium :ensure t)
:custom (with-eval-after-load 'elysium
(elysium-window-size 0.33) ; The elysium buffer will be 1/3 your screen (setq
(elysium-window-style 'vertical)) ; Can be customized to horizontal ;; The elysium buffer will be 1/3 your screen
elysium-window-size 0.33
;; Elysium buffer will be vertical
elysium-window-style 'vertical))
;; Merging with SMerge ;; Merging with SMerge
(use-package smerge-mode :ensure nil :hook (prog-mode . smerge-mode)) (use-package smerge-mode :ensure nil)
(with-eval-after-load 'smerge-mode
(add-hook 'prog-mode-hook #'smerge-mode))
(provide 'icejam-copilot) (provide 'icejam-copilot)
;;; icejam-copilot.el ends here ;;; icejam-copilot.el ends here

1
lisp/icejam-flycheck.el
View file

@ -4,7 +4,6 @@
;; Use flycheck globally to check syntax and compile languages ;; Use flycheck globally to check syntax and compile languages
(use-package flycheck :ensure t) (use-package flycheck :ensure t)
(with-eval-after-load 'flycheck (with-eval-after-load 'flycheck
(global-flycheck-mode t) (global-flycheck-mode t)
(setq flycheck-emacs-lisp-load-path 'inherit) (setq flycheck-emacs-lisp-load-path 'inherit)

23
lisp/icejam-ispell.el
View file

@ -3,22 +3,23 @@
;;; Highlight misspelled words ;;; Highlight misspelled words
;;; Code: ;;; Code:
(use-package ispell (use-package ispell :ensure nil)
:ensure nil (use-package flyspell-correct :ensure t :after flyspell :defer t)
:config (setq ispell-program-name "aspell") (use-package flyspell-correct-ivy :ensure t :after flyspell-correct :defer t)
(setq ispell-extra-args
'("--run-together" "--run-together-limit=5" "--run-together-min=2"))
:hook ((prog-mode text-mode markdown-mode) . flyspell-mode))
(add-hook 'flyspell-mode-hook (lambda () (with-eval-after-load 'ispell
(setq
ispell-program-name "aspell"
ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2"))
(add-hook 'prog-mode-hook #'flyspell-mode)
(add-hook 'text-mode-hook #'flyspell-mode)
(add-hook 'markdown-mode-hook #'flyspell-mode)
(add-hook 'flyspell-mode-hook (lambda ()
(unbind-key "C-," flyspell-mode-map) (unbind-key "C-," flyspell-mode-map)
(unbind-key "C-." flyspell-mode-map) (unbind-key "C-." flyspell-mode-map)
(unbind-key "C-;" flyspell-mode-map) (unbind-key "C-;" flyspell-mode-map)
(unbind-key "C-c $" flyspell-mode-map) (unbind-key "C-c $" flyspell-mode-map)
(unbind-key "C-M-i" flyspell-mode-map))) (unbind-key "C-M-i" flyspell-mode-map))))
(use-package flyspell-correct :ensure t :after flyspell :defer t)
(use-package flyspell-correct-ivy :ensure t :after flyspell-correct :defer t)
(provide 'icejam-ispell) (provide 'icejam-ispell)
;;; icejam-ispell.el ends here ;;; icejam-ispell.el ends here

77
lisp/icejam-prog-mode.el
View file

@ -12,51 +12,46 @@
(global-eldoc-mode t) (global-eldoc-mode t)
;; Revert tag tables without asking ;; Revert tag tables without asking
(require 'etags) (use-package etags :ensure nil)
(setq tags-revert-without-query t) (with-eval-after-load 'etags
(setq tags-revert-without-query t))
;;; Show trailing whitespace and remove whitespace on save ;;; Show trailing whitespace and remove whitespace on save
(use-package whitespace (use-package whitespace :ensure nil)
:commands whitespace-mode
:ensure nil (with-eval-after-load 'whitespace
:defer t (setq
:hook (((prog-mode text-mode conf-mode) . whitespace-mode) ;; Change whitespace style
(before-save . whitespace-cleanup)) whitespace-style #'(face trailing empty)
:config ;; Insert newline on save
(setq whitespace-style #'(face trailing empty) require-final-newline 't)
;;; Insert newline on save
require-final-newline 't)) (add-hook 'prog-mode-hook #'whitespace-mode)
(add-hook 'text-mode-hook #'whitespace-mode)
(add-hook 'conf-mode-hook #'whitespace-mode)
(add-hook 'before-save-hook #'whitespace-cleanup))
(setq-default indent-tabs-mode nil) (setq-default indent-tabs-mode nil)
;; Use colorful, matching parens ;; Use colorful, matching parens
(use-package rainbow-delimiters (use-package rainbow-delimiters :ensure t)
:commands rainbow-delimiters-mode (with-eval-after-load 'rainbow-delimiters
:ensure t
:defer t
:hook (((prog-mode text-mode) . rainbow-delimiters-mode))
:init
;;; Match parenthasis (left-right)
(electric-pair-mode t) (electric-pair-mode t)
(show-paren-mode t)) (show-paren-mode t)
(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
(add-hook 'text-mode-hook #'rainbow-delimiters-mode))
;;; Show hex (#aaa) colors as colors ;;; Show hex (#aaa) colors as colors
(use-package rainbow-mode (use-package rainbow-mode :ensure t)
:commands rainbow-mode (with-eval-after-load 'rainbow-mode
:ensure t (add-hook 'prog-mode-hook #'rainbow-mode)
:hook ((prog-mode text-mode) . rainbow-mode)) (add-hook 'text-mode-hook #'rainbow-mode))
;; Dash integration ;; Dash integration
(use-package dash-at-point (use-package dash-at-point :ensure t)
:commands dash-at-point (with-eval-after-load 'dash-at-point
:ensure t (add-to-list 'dash-at-point-mode-alist '(enh-ruby-mode . "ruby,rubygems,rails"))
:defer t (add-to-list 'dash-at-point-mode-alist '(elixir-ts-mode . "elixir,hex")))
:config
(add-to-list 'dash-at-point-mode-alist
'(enh-ruby-mode . "ruby,rubygems,rails"))
(add-to-list 'dash-at-point-mode-alist
'(elixir-ts-mode . "elixir,hex")))
;; By default, use 2 spaces for indentation ;; By default, use 2 spaces for indentation
(setq tab-width 2) (setq tab-width 2)
@ -69,19 +64,17 @@
(setq-local tab-width step) (setq-local tab-width step)
(setq-local tab-stop-list (number-sequence step 200 step))) (setq-local tab-stop-list (number-sequence step 200 step)))
(use-package column-enforce-mode (use-package column-enforce-mode :ensure t)
:ensure t (with-eval-after-load 'column-enforce-mode
:defer t (global-column-enforce-mode t))
:config (global-column-enforce-mode t))
;; PCRE to emacs regex translations ;; PCRE to emacs regex translations
(use-package pcre2el :ensure t) (use-package pcre2el :ensure t)
;; Visual regexp ;; Visual regexp
(use-package visual-regexp-steroids (use-package visual-regexp-steroids :ensure t :requires (pcre2el))
:ensure t (with-eval-after-load 'visual-regexp-steroids
:requires (pcre2el) (setq vr/engine 'pcre2el))
:config (setq vr/engine 'pcre2el))
(provide 'icejam-prog-mode) (provide 'icejam-prog-mode)
;;; icejam-prog-mode.el ends here ;;; icejam-prog-mode.el ends here

5
lisp/icejam-tree-sitter.el
View file

@ -11,6 +11,7 @@
(defun icejam-tree-sitter-symlink-grammar-objects () (defun icejam-tree-sitter-symlink-grammar-objects ()
"Tree-sitter-langs-build releases grammars as LANG.so, but treesit needs libtree-sitter-LANG.so." "Tree-sitter-langs-build releases grammars as LANG.so, but treesit needs libtree-sitter-LANG.so."
(interactive)
(dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full (dolist (file (directory-files (tree-sitter-langs--bin-dir) 'full
(concat "\\" (car tree-sitter-load-suffixes) "$"))) (concat "\\" (car tree-sitter-load-suffixes) "$")))
;; make symlink (or copy) libtree-sitter-c.so -> c.so ;; make symlink (or copy) libtree-sitter-c.so -> c.so
@ -22,8 +23,8 @@
(make-symbolic-link file target))))) (make-symbolic-link file target)))))
;;;;;;;;;;;;;;;;;;;;;; Tree sitter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;; Tree sitter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(use-package tree-sitter-langs :ensure t (use-package tree-sitter-langs :ensure t)
:config (with-eval-after-load 'tree-sitter-langs
(add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir))) (add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir)))
;; (use-package tree-sitter-indent :ensure t) ;; (use-package tree-sitter-indent :ensure t)