#-*- mode: org -*-
#+TITLE: Emacs Setup for Programming Languages
#+AUTHOR: Volker Edelmann
#+EMAIL:  vedelmann@gmx.de
#+STARTUP: indent
#+OPTIONS:  toc:nil
#+OPTIONS:   ^:{}
src emacs-lisp
  ;; -*- coding: utf-8; lexical-binding: t -*-
#+end_src
* Introduction
- REPL
- editing
  - editing paradigm
  - code completion
  - templates
- moving
- selecting
- code folding
- static syntax checking
- compilation
- debugging
- project-management
** UI
A General Local Leader Map is setup to provide a common/similar UI
other all programming languages used.
The Prefix is C-S-<space>. The ~which-key~ Package provides help on the keys.
If there is need for a modal interface, a Major-Mode-Hydra can be defined.
Bind in mayor-mode keymap to:
#+begin_example
:bind ( :map KEYMAP
  ("M-SPC" . major-mode-hydra))
#+end_example
Also, repeat-maps can help for movement and marking.
** Lisp-like (s-expression) languages 
   - emacs-lisp
   - clojure
   - [guile (scheme)]
   - [hy]
** Languages with Tree-sitter grammars
*** Exploring
- combobulate
- Built-In commands: treesit-explore-mode
*** Tree-sitter
store grammars in a common location
#+begin_src emacs-lisp
      (setq treesit-extra-load-path (list (concat emacsen-dir "treesit/grammars/")                                           )
      )
#+end_src
#+begin_src emacs-lisp
  (use-package emacs
    :mode (("\\.tsx\\'" . tsx-ts-mode))
    :preface
    (defun mp-setup-install-grammars ()
      "Install Tree-sitter grammars if they are absent."
      (interactive)
      (dolist (grammar
                '((css . ("https://github.com/tree-sitter/tree-sitter-css" "v0.20.0"))
                  (html . ("https://github.com/tree-sitter/tree-sitter-html" "v0.20.1"))
                  (javascript . ("https://github.com/tree-sitter/tree-sitter-javascript" "v0.20.1" "src"))
                  (json . ("https://github.com/tree-sitter/tree-sitter-json" "v0.20.2"))
                  (python . ("https://github.com/tree-sitter/tree-sitter-python" "v0.20.4"))
                  (toml "https://github.com/tree-sitter/tree-sitter-toml")
                  (tsx . ("https://github.com/tree-sitter/tree-sitter-typescript" "v0.20.3" "tsx/src"))
                  (typescript . ("https://github.com/tree-sitter/tree-sitter-typescript" "v0.20.3" "typescript/src"))
                  (yaml . ("https://github.com/ikatyang/tree-sitter-yaml" "v0.5.0"))))
        (add-to-list 'treesit-language-source-alist grammar)
    ;; Only install `grammar' if we don't already have it
    ;; installed. However, if you want to *update* a grammar then
    ;; this obviously prevents that from happening.
    (unless (treesit-language-available-p (car grammar))
      (treesit-install-language-grammar (car grammar)))))
    ;; Optional, but recommended. Tree-sitter enabled major modes are
    ;; distinct from their ordinary counterparts.
    ;;
    ;; You can remap major modes with `major-mode-remap-alist'. Note
    ;; that this does *not* extend to hooks! Make sure you migrate them
    ;; also
    (dolist (mapping
             '((python-mode . python-ts-mode)
               (css-mode . css-ts-mode)
               (typescript-mode . typescript-ts-mode)
               (js2-mode . js-ts-mode)
               (bash-mode . bash-ts-mode)
               (css-mode . css-ts-mode)
               (json-mode . json-ts-mode)
               (js-json-mode . json-ts-mode)))
      (add-to-list 'major-mode-remap-alist mapping))
    :config
    (mp-setup-install-grammars)
    ;; Do not forget to customize Combobulate to your liking:
    ;;
    ;;  M-x customize-group RET combobulate RET
    ;;
    )
#+end_src
**** Additional Grammars
Repos, where grammars are found:
#+begin_src emacs-lisp
  (setq treesit-language-source-alist
        '(
          (awk "https://github.com/Beaglefoot/tree-sitter-awk")
          (bash "https://github.com/tree-sitter/tree-sitter-bash")
          (c . ("https://github.com/tree-sitter/tree-sitter-c"))
          (cpp . ("https://github.com/tree-sitter/tree-sitter-cpp"))
          (cmake . ("https://github.com/uyha/tree-sitter-cmake"))
  	(d . ("https://github.com/gdamore/tree-sitter-d"))
          (julia "https://github.com/tree-sitter/tree-sitter-julia")
          (kotlin "https://github.com/fwcd/tree-sitter-kotlin")
          (lua . ("https://github.com/Azganoth/tree-sitter-lua"))
          (make "https://github.com/alemuller/tree-sitter-make")
          (markdown "https://github.com/ikatyang/tree-sitter-markdown")
          (perl "https://github.com/tree-sitter-perl/tree-sitter-perl")
          (php . ("https://github.com/tree-sitter/tree-sitter-php"))
          (sql "https://github.com/m-novikov/tree-sitter-sql")
          (scala "https://github.com/tree-sitter/tree-sitter-scala")
          )
        )
#+end_src
 
Check if a grammar is available:
(treesit-language-available-p 'd)
* Visuals
** Parentheses, brackets, ...
#+begin_src emacs-lisp
(require 'elec-pair)
#+end_src
** Project Browser
*** DISCARDED dired-sidebar
cannot display fd-dired queries
* Folding
* Editing
In Lisp-like modes, there are perhaps better alternatives:
- lispy
- paredit
- smartparens
** vim-Style
using viper-mode
Backup: viper mode can temporarily activated
** DONE Puni
wrong direction
* Project Management
#+begin_src emacs-lisp
    (put 'compile-command         'safe-local-variable t)
    (setq enable-local-variables :safe)
#+end_src
* Static Checkers/Linters
Although flymake is an Emacs built-in, flycheck has more checkers and often works without further configuration when a checker/linter is available vi the OS path settings.
** Builtin: flymake
Diagnostics: flymake-show-buffer-diagnostics
#+begin_src emacs-lisp
  (require 'flymake)
  (use-package emacs
    :config
       (setq flymake-mode-line-lighter t)
  )
#+end_src
* Finding and referencing symbols
** Language Servers
https://langserver.org/
*** Built-In eglot 
#+begin_src emacs-lisp
  (use-package eglot
  :custom
    (eglot-autoshutdown t)
    (eglot-events-buffer-size 0)
    (eglot-extend-to-xref nil)
    (eglot-ignored-server-capabilities
     '(:hoverProvider
       :documentHighlightProvider
       :documentFormattingProvider
       :documentRangeFormattingProvider
       :documentOnTypeFormattingProvider
       :colorProvider
       :foldingRangeProvider))
    (eglot-stay-out-of '(yasnippet tempel))
  )
#+end_src
* References
#+begin_src emacs-lisp
  (use-package xref
    :pin gnu
    :custom
    (xref-auto-jump-to-first-xref t)
    (xref-file-name-display 'project-relative)
    (xref-search-program 'ripgrep)
    :config
    (setq xref-show-xrefs-function       #'consult-xref
          xref-show-definitions-function #'consult-xref) 
    )
#+end_src
* Documentation
#+begin_src emacs-lisp
  (use-package eldoc
    :pin gnu
    :diminish
    :bind ("s-d" . #'eldoc)
    :custom
    (eldoc-echo-area-prefer-doc-buffer t)
    (eldoc-echo-area-use-multiline-p t))
#+end_src
* Folding
Depending on the mode, hideshow may be a good solution:
 #+begin_src emacs-lisp
   (use-package hideshow)
   (defun toggle-fold ()
     (interactive)
     (save-excursion
       (end-of-line)
       (hs-toggle-hiding)))
 #+end_src
 
 
#+begin_src emacs-lisp
;;; programming-common-setup.el ends here
#+end_src

* XML
- REPL
- tree-sitter
- Language-Server
** Tree-sitter
There is no nxml-ts-mode yet.
- moving around: nxml-mode
Forward element
    C-M n 
Backward element
    C-M p 
UP element
    C-M u 
Down element
    C-M d 
  
- selections:
  - expreg
  - evil-textobj-tree-sitter
- folding
  - hideshow
    
** Linter
Build into nxml-mode (needs a schema).
https://lgfang.github.io/mynotes/emacs/emacs-xml.html#sec-3
** Formatter
  #+begin_src emacs-lisp
  #+end_src
** Auto Completion
nxml-mode
https://www.gnu.org/software/emacs/manual/html_node/nxml-mode/Completion.html
     
** Konfiguration
  #+begin_src emacs-lisp
    (require 'nxml-mode)
    (require 'sgml-mode)
    (require 'nxml-mode)
    (add-to-list 'hs-special-modes-alist
		 '(nxml-mode
		   "<!--\\|<[^/>]*[^/]>"
		   "-->\\|</[^/>]*[^/]>"
		   "<!--"
		   sgml-skip-tag-forward
		   nil))
    (use-package emacs
      :pin gnu
      :bind (
	     :map nxml-mode-map
		  ("C-+"      . expreg-expand)
		  ("C--"      . expreg-contract)
		  ("C-c h"    . hs-toggle-hiding)
		  )
      :hook
      (nxml-mode . hs-minor-mode)
      (nxml-mode . yas-minor-mode)
      (nxml-mode . flycheck-mode)
      :config
      )
  #+end_src
There is a Hydra defined for ts-movement, open with <f5>.
** Language Server
*** void-Linux
*** Windows
#+begin_src sh
#+end_src
** UI
*** General local leader
Prefix is C-S-<space>
  #+begin_src emacs-lisp
  (local-leader nxml-mode-map
    "+"        '(yas-insert-snippet         :wk "code snippets")
;;    "j"        '(hydra-tree-sitter-move/body           :wk "movement hydra")
    "m"        '(:ignore t :which-key "mark/select")
    "mp"       '(mark-paragraph :wk "paragraph")
    "f"        '(hydra-fold/body :wk "Folding")
   ;; "h"        '(hs-toggle-hiding :wk "Folding: toggle")
    )
#+end_src

#-*- mode: org -*-
#+TITLE: Emacs Setup for the TCL/TK Programming Language
#+AUTHOR: Volker Edelmann
#+EMAIL:  vedelmann@gmx.de
#+STARTUP: indent
#+OPTIONS:  toc:nil
#+OPTIONS:   ^:{}
#+begin_src emacs-lisp
  ;; -*- coding: utf-8; lexical-binding: t -*-
#+end_src
* TCL/TK
Category: Others
A TCL program follows very simple grammatical rules. It is very easy to
write a parser.
There is no language-server or tree-sitter grammar available as there seems to be no
need for it.a TCL is considered a homoiconic language.
** REPL
** Selections
#+begin_src emacs-lisp
  (use-package expand-region
    :config
    ;; patch expand-region for TCL
    (defun er/add-tcl-mode-expansions ()
      (make-variable-buffer-local 'er/try-expand-list)
      (setq er/try-expand-list (append
				er/try-expand-list
				'(er/mark-word
				  er/mark-defun
				  er/mark-paragraph)
				)
	    )
      )
    (er/enable-mode-expansions 'tcl-mode 'er/add-tcl-mode-expansions)
    )
#+end_src
** Folding
Best option is to use the built-in hideshow package.
I would like the namespaces to be left unfolded if hs-fold-all is executed. 
#+begin_src emacs-lisp
  (use-package hideshow
    :custom
    (hs-isearch-open t)
    )
#+end_src
** Static Checker
flycheck uses nagelfar. Put it on the PATH.
#+begin_src emacs-lisp
  (add-to-list 'display-buffer-alist
	       `(,(rx bos "*Flycheck errors*" eos)
		 (display-buffer-reuse-window
		  display-buffer-in-side-window)
		 (side            . bottom)
		 (reusable-frames . visible)
		 (window-height   . 0.33)))
#+end_src
  
** TCL/TK
#+begin_src emacs-lisp
  (use-package tcl
    :mode (("\\.tcl\\'" . tcl-mode)
           ("\\.tcons\\'" . tcl-mode)
           ("\\.svcf\\'" . tcl-mode)
           ("\\.exp\\'" . tcl-mode))
    :bind
    (:map tcl-mode-map
          ("C-c C-z"      . inferior-tcl)
          ("C-+"          . er/expand-region)
          ("C-<return>"   . ve/tcl-eval-region-or-line)
          ("C-S-<return>" . tcl-eval-defun)
          ("<tab>"        . completion-at-point)
          ("C-c C-t" . nil)
          )
    :init
    (env-setup "tcl")
    (defun ve/tcl-eval-buffer ()
      (interactive)
      (message "buffer")
      (tcl-eval-region (point-min) (point-max))
      (keyboard-quit)
      )
    (defun ve/tcl-eval-region-or-line ()
      (interactive)
      (if (region-active-p)
          (tcl-eval-region (region-beginning) (region-end))
        (tcl-eval-region (progn
                           (beginning-of-line) (point))
                         (progn
                           (end-of-line) (point))
                         )
        )
      (keyboard-quit)
      )
    (defun ve/tcl-mode-customization ()
      "My customization for `tcl-mode'."
      (add-to-list 'completion-at-point-functions #'cape-keyword)
      (add-to-list 'completion-at-point-functions #'cape-dabbrev)
      )
    (defun ve/outline-tcl ()
      "Fold only definitions for TCL buffers."
      (setq outline-regexp
  	  (rx (or
  	       ;; Definitions
  	       (group (group (* space)) bow (or "proc" "namespace") eow)
  	       ;; Decorators
  	       (group (group (* space)) "@"))))
      (my/outline-overview))
    :config
    (setq tcl-indent-level 4
          tcl-continued-indent-level 8)    
    (setq tcl-application "tclsh") ;; jimsh tclsh wish
    (setq flycheck-check-syntax-automatically '(save mode-enabled))
    (setq tcl-help-directory-list '("/usr/lib/tclx8.6/help"))
    
    (add-hook 'tcl-mode-hook #'ve/tcl-mode-customization)
    (add-hook 'tcl-mode-hook #'ve/outline-tcl)
    (add-hook 'tcl-mode-hook #'electric-pair-mode)
    (add-hook 'tcl-mode-hook #'electric-indent-mode)
    :hook (tcl-mode . yas-minor-mode)
    (tcl-mode . flycheck-mode)
    (tcl-mode . hs-minor-mode)
    (tcl-mode . outline-minor-mode)
    )
#+end_src
** UI
#+begin_src emacs-lisp
  (local-leader tcl-mode-map
    "C-z"      '(inferior-tcl         :wk "REPL")
    "l"        '(list-flycheck-errors :wk "diagnostics")
    "+"        '(yas-insert-snippet   :wk "code snippets")
    "b"        '(ve/tcl-eval-buffer   :wk "eval buffer")
    "s"        '(:ignore t :which-key "mark/select")
    "sb"       '(mark-whole-buffer :wk "buffer")
    "sf"       '(mark-function :wk "function")
    "sp"       '(mark-paragraph   :wk "paragraph")
    "sw"       '(er/mark-word     :wk "word")
    "sc"       '(er/mark-comment  :wk "comment")
    "f"        '(:ignore t :which-key "folding")
    "f>"       '(hs-show-block :wk "show block")
    "f<"       '(hs-hide-block :wk "hide block")
    "ft"       '(hs-toggle-hiding :wk "toggle block visibility")
    "fs"       '(hs-show-all   :wk "show all")
    "fl"       '(hs-hide-level   :wk "hide level")
    )
#+end_src
    "t"        '(:ignore t :which-key "tags")
    "tf"       '(ggtags-find-tag       :wk "find tag")
    "tF"       '(ggtags-find-tag-dwim  :wk "find tag dwim")
    "t$"       '(ggtags-find-tag-regexp :wk "find tag regexp")
    "td"       '(ggtags-find-definition :wk "find definition")
    "tr"       '(ggtags-find-reference :wk "find reference")
    "tg"       '(ggtags-grep           :wk "search db")
    "t%"       '(ggtags-query-replace  :wk "replace")
    "tu"       '(ggtags-update-tags    :wk "update db")
* TODO Expect

* SQL
- REPL
- tree-sitter
- Language-Server
- Linter
** Tree-sitter
There is no sql-ts-mode yet.
- moving around: ts-movement
- selections:
  - expreg
  - evil-textobj-tree-sitter
- folding
    
** TODO pgformat
No great value
** sqlfluff
installed as a command line tool
- linter
- formatter
- template engine
unfortunately not working with emacs
    
** Linter
Uses sqlint ruby gem from Steve Purcell
  #+begin_src emacs-lisp
  (require 'sql)
(require 'flycheck)
  #+end_src
** Formatter
  #+begin_src emacs-lisp
  (use-package sqlup-mode)
  #+end_src
  #+begin_src emacs-lisp
(require 'sql-indent)
;; Update indentation rules, select, insert, delete and update keywords
;; are aligned with the clause start
(defvar my-sql-indentation-offsets-alist
  `((select-clause 0)
    (insert-clause 0)
    (delete-clause 0)
    (update-clause 0)
    ,@sqlind-default-indentation-offsets-alist))
(add-hook 'sqlind-minor-mode-hook
	  (lambda ()
	  (setq sqlind-indentation-offsets-alist
		my-sql-indentation-offsets-alist)))
  #+end_src
     
** Konfiguration
  #+begin_src emacs-lisp
  (require 'sql)
(use-package emacs
  :pin gnu
  :bind (
	 :map sql-mode-map
	 ("C-+"      . expreg-expand)
	 ("C--"      . expreg-contract)
	 ("S-<return>"   . sql-send-string)
	 ("C-<return>"   . sql-send-region)
	 ("M-<return>"   . sql-send-paragraph)
	 )
  :hook
  (sql-mode . yas-minor-mode)
  (sql-mode . flycheck-mode)
  (sql-mode . sqlup-mode)
  :config
  )
  #+end_src
There is a Hydra defined for ts-movement, open with <f5>.
** Language Server
*** void-Linux
*** Windows
Using MSYS2:
#+begin_src sh
#+end_src
** UI
*** General local leader
Prefix is C-S-<space>
  #+begin_src emacs-lisp
  (local-leader sql-mode-map
    ;;   "c"      '(sql-connect                  :wk "connect to database")
    ;;   "p"        '(python-shell-switch-to-shell :wk "py-shell")
    "+"        '(yas-insert-snippet         :wk "code snippets")
    "j"        '(hydra-tree-sitter-move/body           :wk "movement hydra")
    "x"        '(:ignore t :which-key "execute in REPL")
    "xb"       '(sql-send-buffer    :wk "buffer")
    "xp"       '(sql-send-paragraph :wk "paragraph")
    "xs"       '(sql-send-string    :wk "string")
    "m"        '(:ignore t :which-key "mark/select")
    "mp"       '(mark-paragraph :wk "paragraph")
    "mf"       '(mark-defun     :wk "function")
    "mF"       '((evil-textobj-tree-sitter-get-textobj "function.outer") :wk "function")
    "f"        '(hydra-fold/body :wk "Folding")
    )
#+end_src

* Python
Python gehort zu den popularsten Sprachen (Stand 2023). Viele Leute entwicklen mit Emacs.
Daher ist die Unterstutzung der Sprache sehr gut. Eine Tree-Sitter-Grammatik und
mehrere LSP-Server sind verfugbar.
** Tree-sitter
#+begin_src emacs-lisp
  (push '(python-mode . python-ts-mode) major-mode-remap-alist)
#+end_src
- moving around: ts-movement
- selections:
  - expreg
  - ts-movement Hydra
  - evil-textobj-tree-sitter
- folding
    
** Konfiguration
  #+begin_src emacs-lisp
    (use-package python
      :pin gnu
      :bind (
	     :map python-ts-mode-map
	     ("C-+"      . expreg-expand)
	     ("C--"      . expreg-contract)
	     ("S-<return>"   . python-shell-send-statement)
	     ("C-<return>"   . python-shell-send-region)
	     ("M-<return>"   . nil)
	     )
      :hook
      (python-ts-mode . ts-movement-mode)
      (python-ts-mode . yas-minor-mode)
      :config
      (when (executable-find "ipython3")
	(setq python-shell-interpreter "ipython3"
	      python-shell-interpreter-args "--simple-prompt --classic")))
  #+end_src
There is a Hydra defined for ts-movement, open with C-.
** Language Server
Verwende den jedi-Server, da er auf allen Plattformen zur Verfügung stand.
#+begin_src emacs-lisp
  (defun my/eglot-python-setup ()
    (eglot-ensure)
    ;; eglot wipes out the flymake functions; re-add
    (setq-local python-flymake-command '("flake8" "--max-line-length=100" "-"))
    (add-hook 'eglot-managed-mode-hook
	      (lambda ()
		(add-hook 'flymake-diagnostic-functions #'python-flymake t t))
	      nil t))
  (add-hook 'python-mode-hook 'my/eglot-python-setup)
  (add-hook 'python-ts-mode-hook 'my/eglot-python-setup)
#+end_src
Prerequisites:
*** void-Linux
#+begin_src sh
  doas xbps-install -Sy jedi
  doas xbps-install -Sy flake8
  doas xbps-install -Sy black
  pip install -U jedi-language-server
#+end_src
*** Windows
Using MSYS2:
#+begin_src sh
  pacman -Sy mingw-w64-python-jedi
  pacman -Sy mingw-w64-x86_64-python-ipython
  pacman -Sy mingw-w64-x86_64-python-black
  pacman -Sy mingw-w64-x86_64-python-flake8
  pacman -Sy mingw-w64-x86_64-python-pip
  pip install -U jedi-language-server
#+end_src
** UI
*** General local leader
(defun elpy-shell-switch-to-shell ()
  "Switch to inferior Python process buffer."
  (interactive)
  (setq elpy--shell-last-py-buffer (buffer-name))
  (pop-to-buffer (process-buffer (elpy-shell-get-or-create-process))))
Prefix is C-S-<space>
#+begin_src emacs-lisp
  (local-leader python-ts-mode-map
    "C-p"      '(run-python                 :wk "start py-shell")
    "p"        '(python-shell-switch-to-shell :wk "py-shell")
    "+"        '(yas-insert-snippet         :wk "code snippets")
  
    "b"        '(python-shell-send-buffer   :wk "eval buffer")
    "F"        '(python-shell-send-function :wk "eval function")
    "f"        '(hydra-fold/body :wk "Folding")
    "m"        '(hydra-tree-sitter-move/body        :wk "movement hydra")
    "s"        '(:ignore t :which-key "mark/select")
    "sp"       '(mark-paragraph :wk "paragraph")
    "sf"       '(mark-defun     :wk "function")
    "sF"       '((evil-textobj-tree-sitter-get-textobj "function.outer") :wk "function")
    )
#+end_src

#-*- mode: org -*-
#+TITLE: Emacs Setup for Julia Programming Language
#+AUTHOR: Volker Edelmann
#+EMAIL:  vedelmann@gmx.de
#+STARTUP: indent
#+OPTIONS:  toc:nil
#+OPTIONS:   ^:{}
#+begin_src emacs-lisp
  ;; -*- coding: utf-8; lexical-binding: t -*-
#+end_src
* Tree-sitter
#+begin_src emacs-lisp
  (push '(julia-mode . julia-ts-mode) major-mode-remap-alist)
#+end_src
- moving around: ts-movement
- selections:
  - expreg
  - paragraph-selections, if blank lines are used to structure the code
* Folding
*origami* funktioniert gut f"ur Julia
* Julia
#+begin_src emacs-lisp
    (use-package eglot-jl
        :commands eglot-jl-init
	:config
	(setq eglot-connect-timeout 300)
	(setq eglot-jl-julia-command julia-program)
    )
#+end_src
#+begin_src emacs-lisp
	(use-package julia-ts-mode
	  :after eglot
	  :init (setenv "JULIA_NUM_THREADS" "6")
	  :bind (
	     :map julia-ts-mode-map
		("C-c p"    . er/mark-paragraph)
		("C-c f"    . er/mark-defun)
		("C-c s"    . er/mark-symbol)
		("C-+"      . expreg-expand)
		("C--"      . expreg-contract)
		("<tab>"    . completion-at-point)
	      )
	  :hook
	   (julia-ts-mode . julia-snail-mode)
	   (julia-ts-mode . eglot-ensure)
	   (julia-ts-mode . eglot-jl-init)
;;	   (julia-ts-mode . ts-movement-mode)
	   (julia-ts-mode . yas-minor-mode)
	  )
#+end_src
    |---------+---------------------------------+----------------------------------------------------------------------------------------------------------------------------------------|
    | key     | command                         | description                                                                                                                            |
    |---------+---------------------------------+----------------------------------------------------------------------------------------------------------------------------------------|
    | C-c C-z | julia-snail                     | start a REPL; flip between REPL and source                                                                                             |
    | C-c C-a | julia-snail-package-activate    | activate the project using Project.toml                                                                                                |
    | C-c C-d | julia-snail-doc-lookup          | display the docstring of the identifier at point                                                                                       |
    | C-c C-l | julia-snail-send-line           | evaluate current line in the current module (or in Main with prefix arg; or copy directly to REPL with two prefix args)                |
    | C-c C-r | julia-snail-send-region         | evaluate active region in the current module (or in Main with prefix arg; or copy directly to REPL with two prefix args)               |
    | C-c C-e | julia-snail-send-dwim           | if region active, evaluate it in current module; else if on top-level block, evaluate it in current module; else evaluate current line |
    | C-c C-c | julia-snail-send-top-level-form | evaluate end-terminated block around the point in the current module                                                                   |
    | C-M-x   | julia-snail-send-top-level-form | ditto                                                                                                                                  |
    | C-c C-R | julia-snail-update-module-cache | update module-nested include cache (mainly for Revise)                                                                                 |
    | C-c C-k | julia-snail-send-buffer-file    | include() the current buffer’s file                                                                                                    |
    |---------+---------------------------------+----------------------------------------------------------------------------------------------------------------------------------------|
#+begin_src emacs-lisp
  (use-package julia-snail
    :after julia-ts-mode
    :custom
    (julia-snail-terminal-type :eat)
    :config
    (setq julia-snail-use-emoji-mode-lighter t)
    (setq julia-snail-popup-display-eval-results nil)
    (setq julia-snail-repl-display-eval-results t)
    (setq julia-snail-show-error-window t)
    (setq julia-snail-doc-lookup t)
    (setq julia-snail-multimedia-buffer-style :single-reuse)
    (setq julia-snail/ob-julia-mirror-output-in-repl t)
    (setq julia-snail/ob-julia-capture-io t)
    ;;   :init ;; Setup completion at point
    ;;   (add-hook 'julia-snail-mode-hook
    ;;      (lambda ()
    ;;    (remove-hook 'completion-at-point-functions #'julia-snail-repl-completion-at-point t)
    ;;    )
    ;;   )
    :bind (
           :map julia-snail-mode-map
           ("S-<return>"   . julia-snail-send-line)
           ("C-<return>"   . julia-snail-send-region)
           ("M-<return>"   . julia-snail-send-dwim)
           ("C-M-x"        . nil)
           :map julia-snail-repl-mode-map
           ("M-o"   . ace-window)
           )
    )
#+end_src
not working (call function manually when repl is running):
   :hook
	 (julia-snail-multimedia-toggle-display-in-emacs)
** Formatting
use snail extension
** TODO Linting
** TODO Debugging
** UI
*** General local leader
Prefix is C-S-<space>
#+begin_src emacs-lisp
  (local-leader julia-ts-mode-map
    "C-z"      '(julia-snail          :wk "REPL")
    "+"        '(yas-insert-snippet   :wk "code snippets")
    "b"        '(julia-snail-send-buffer-file :wk "eval buffer")
    "f"        '(hydra-fold/body :wk "Folding")
    "m"        '(hydra-tree-sitter-move/body     :wk "movement hydra")
    "s"        '(:ignore t :which-key "mark/select")
    "sp"       '(mark-paragraph :wk "paragraph")
    "sf"       '(mark-defun     :wk "function")
    )
#+end_src
Categories not yet used:
"Debug"
   (
    ()
   )
Test"
   (
    ("t" ert "prompt")
    ("T" (ert t) "all")
    ("F" (ert :failed) "failed")
   )
"Doc"
   (
    ("i" info-lookup-symbol "info lookup")
   )

* Javascript, Typescript, JSON, YAML, Vega-Lite
- moving around: ts-movement
- selections:
  - expreg
  - ts-movement Hydra
  - evil-textobj-tree-sitter
- folding
    
* JSON
** Navigator
#+begin_src emacs-lisp
  (use-package json-navigator)
#+end_src
** Tree-sitter
#+begin_src emacs-lisp
  (dolist (mapping
           '(           (json-mode . json-ts-mode)
			(js-json-mode . json-ts-mode)))
    (add-to-list 'major-mode-remap-alist mapping))
#+end_src
** Linting
use "jq".
** Formatting
use "jq":
#+begin_example
jq . --indent 2 File.json
jq --color-output . file1.json file1.json | less -R
command_with_json_output | jq .
jq # stdin/"interactive" mode, just enter some JSON
jq <<< '{ "foo": "lorem", "bar": "ipsum" }'
#+end_example
There is also a --sort-keys option
"jq ." is great as a pretty-printer, but it comes with a caveat: jq (up to and including jq version 1.5) will alter the values of very large and
very small numbers because it parses numeric values as IEEE 754 64-bit values. To check whether your favorite pretty-printer has the same issue,
try this value: 1e1000. 
** Language Server
* Prerequisites
*** Node.js
some packages are deprecated
sudo npm install -g vega vega-lite vega-cli
sudo npm install -g vscode-json-languageserver
#+end_src
*** Configuration
#+begin_src elisp
  (use-package json-ts-mode
    :pin gnu   
    :bind (
	   :map json-ts-mode-map
	   ("M-<return>"   . nil)
	   )
    :hook (
	   ;;	   (json-ts-mode . ts-movement-mode)
	   (json-ts-mode . yas-minor-mode)
	   (json-ts-mode . flycheck-mode)
	   )
    :config
    (add-hook 'json-ts-mode-hook (lambda () (eglot-ensure)))
    )
#+end_src
*** Configuration
#+begin_src emacs-lisp
  (use-package vegalite-mode
    :load-path ("ve")
    :hook (
	   (vegalite-mode . flycheck-mode)
	   (vegalite-mode . abbrev-mode)
	   )
    :config
    (setq treesit-font-lock-level 2)
    (add-hook 'vegalite-mode-hook (lambda () (eglot-ensure)))
    )
(require 'vegalite-mode)
#+end_src

* Tree-sitter
#+begin_src emacs-lisp
  (require 'java-ts-mode)
  (push '(java-mode . java-ts-mode) major-mode-remap-alist)
#+end_src
- selections:
  - expreg
  - expand-region (er/...)
* Folding
    
* Language Server
Although there are 3 language servers for Java listed on https://langserver.org/,
installation on Linux is a pain and on Windows I was not able to get it working.
* Gnu Global
I consider a better alternative to a language-server to be the use of
Gnu Global (explicit support for Java) or ctags.
The use of CEDET/EDE/senator/semantic-db was avoided because of the complexity it
introduces.
  #+begin_src emacs-lisp
(require 'ggtags)
  #+end_src
  
* Snippets
Additional YaSnippets
#+begin_src emacs-lisp
  (use-package java-snippets)
#+end_src
* Linting
** Syntax Check
Use Checkstyle with sun-rules.
#+begin_src emacs-lisp
    (require 'flycheck)
  (flycheck-define-checker java-checkstyle
      " a java checker "
      :command ("java"
		"-jar"
		(eval (concat emacsen-dir "java\\checkstyle-9.0.1-all.jar"))
		"-c" "sun_checks.xml"
		"-f" "xml"
		source)
      :error-parser flycheck-parse-checkstyle
     ;; :standard-input
      :modes (java-mode java-ts-mode)
      )
#+end_src
* Konfiguration
  #+begin_src emacs-lisp
    (use-package java-ts-mode
      :ensure nil
      :config
      (defun ve/java-mode-hook ()
	(add-to-list 'completion-at-point-functions #'ggtags-completion-at-point)
      )
      :bind (
	     :map java-ts-mode-map
	     ("C-+" . expreg-expand)
	     ("C--" . expreg-contract)
	     ("C-c f" . er/mark-defun)
      )
      :hook
      (java-ts-mode . ve/java-mode-hook)
      (java-ts-mode . ggtags-mode)
      (java-ts-mode . flycheck-mode)
      (java-ts-mode . yas-minor-mode)
      (java-ts-mode . eldoc-mode)
      )
  #+end_src
* General local leader
Prefix is C-S-<space>
#+begin_src emacs-lisp
  (local-leader java-ts-mode-map
    "+"        '(yas-insert-snippet    :wk "code snippets")
    "l"        '(flycheck-list-errors  :wk "linter window")
    "f"        '(hydra-fold/body :wk "Folding")
    "m"        '(hydra-tree-sitter-move/body        :wk "movement hydra")
    ;; try combobulate - ts-movement mode not useful
    "b"        '(:ignore t :which-key "TODO: build/run/debug")
    "t"        '(:ignore t :which-key "tags")
    "tf"       '(ggtags-find-tag       :wk "find tag")
    "tF"       '(ggtags-find-tag-dwim  :wk "find tag dwim")
    "t$"       '(ggtags-find-tag-regexp :wk "find tag regexp")
    "td"       '(ggtags-find-definition :wk "find definition")
    "tr"       '(ggtags-find-reference :wk "find reference")
    "tg"       '(ggtags-grep           :wk "search db")
    "t%"       '(ggtags-query-replace  :wk "replace")
    "tu"       '(ggtags-update-tags    :wk "update db")
    "d"        '(:ignore t :which-key "doc")
    "s"        '(:ignore t :which-key "mark/select")
    ;; make this a hydra
    "sp"       '(mark-paragraph  :wk "paragraph")
    "sf"       '(er/mark-defun   :wk "function")
    "ss"       '(er/mark-symbol-with-prefix :wk "symbol")
    "s+"       '(expreg-expand   :wk "expand region")
    "s-"       '(expreg-contract :wk "unexpand region")
    )
#+end_src

* Tree-sitter
#+begin_src emacs-lisp
  (push '(kotlin-mode . kotlin-ts-mode) major-mode-remap-alist)
#+end_src
- folding ?
- movement ?
- selections ?
    
* Language Server
Feature list
* Symbol Look up
- eglot
* Linting
- flycheck
* Snippets
- tempel
- yasnippets
  
* Konfiguration
  #+begin_src emacs-lisp
  (use-package d-mode
    :pin gnu
    :config
    (defun ve/d-mode-hook ()
      (add-to-list 'eglot-stay-out-of 'flymake)
      )
    :config
    (add-to-list 'eglot-server-programs `((d-mode d-ts-mode) . ("serve-d")))
    :bind (
	   :map d-mode-map
	   )
    :hook
    (d-mode . flycheck-mode)
    (d-mode . eglot-ensure)
    (d-mode . yas-minor-mode)
    (d-mode . hs-minor-mode)
    (d-mode . ve/d-mode-hook)  
    )
  #+end_src
* UI
Prefix is C-S-<space>
#+begin_src emacs-lisp
  (local-leader <mode>-ts-mode-map
    "+"        '(yas-insert-snippet    :wk "code snippets")
    "l"        '(flycheck-list-errors  :wk "linter window")
    "f"        '(hydra-fold/body :wk "Folding")
    ;; try combobulate - ts-movement mode not useful
    "b"        '(:ignore t :which-key "TODO: build/run/debug")
    "d"        '(:ignore t :which-key "doc")
    "s"        '(:ignore t :which-key "mark/select")
    )
#+end_src