#+title: Emacs setup for use with LaTeX, Org, and Python
#+author: Gerard Vermeulen
#+latex_class: article
#+latex_class_options: [11pt,a4paper,english,svgnames,tables]
#
#+babel: :cache no
#
#+macro: kbd @@html:<kbd>$1</kbd>@@@@latex:\colorbox{PaleTurquoise}{\texttt{$1}}@@
#
#+property: header-args :tangle init.el
#+property: header-args:emacs-lisp :exports code :results silent
#+property: header-args:latex-header :tangle no
#+property: header-args:latex-extra-header :tangle no
#
#+startup: content

* LaTeX headers                                                    :noexport:

#+begin_src latex-header
  % LANGUAGE:
  \usepackage{babel}
  \usepackage{fvextra}
  \usepackage{csquotes}
  % LISTS:
  \usepackage{enumitem}
  \setlist{noitemsep}
  % TECHNICS:
  \usepackage{siunitx}
  \usepackage{tikz}
  % LISTINGS:
  % Section 2.6 of caption-eng.pdf (texdoc caption) explains that the sign
  % of "skip" depends on the assumption "position=above" or "position=below".
  % The assumption should match the real caption position in the LaTeX code.
  \usepackage{caption}
  \usepackage[newfloat]{minted}
  \captionsetup[listing]{position=below,skip=0em}
  \usemintedstyle{xcode}
  % TABLES:
  % https://tex.stackexchange.com/questions/341205/
  % what-is-the-difference-between-tabular-tabular-and-tabularx-environments
  % https://emacs.stackexchange.com/questions/26179/
  % change-org-mode-table-style-just-for-latex-export
  % https://tex.stackexchange.com/questions/468585/
  % table-formatting-using-siunitx
  \usepackage{booktabs}
  \usepackage{colortbl}
  \usepackage{tabularx}  % DANGER: beware of Org table :width and :align options!
  % FANCY HEADERS:
  \usepackage{fancyhdr}
  \usepackage{lastpage}
  % PAGE GEOMETRY:
  \usepackage[
    headheight=20mm,
    top=40mm,
    bottom=20mm,
    left=60pt,
    right=60pt,
    heightrounded,
    verbose,
  ]{geometry}
#+end_src

#+begin_src latex-header
  % Make section, subsection and subsubsection implicit float barriers.
  % https://tex.stackexchange.com/questions/118662/use-placeins-for-subsections
  % Make section an implicit float barrier:
  \usepackage[section]{placeins}
  % Make subsection an implicit float barrier:
  \makeatletter
  \AtBeginDocument{%
    \expandafter\renewcommand\expandafter\subsection\expandafter{%
      \expandafter\@fb@secFB\subsection
    }%
  }
  \makeatother
  % Make subsubsection an implicit float barrier:
  \makeatletter
  \AtBeginDocument{%
    \expandafter\renewcommand\expandafter\subsubsection\expandafter{%
      \expandafter\@fb@secFB\subsubsection
    }%
  }
  \makeatother
#+end_src

#+begin_src latex-header
  % Add fancy headers and footers to normal pages.
  \pagestyle{fancy}
  \fancyhf{}
  \renewcommand{\footrulewidth}{0.4pt}
  \fancyfoot[C]{\emph{
      Emacs setup for use with \LaTeX{}, Org, and Python -- Gerard Vermeulen}}
  \renewcommand{\headrulewidth}{0.4pt}
  \fancyhead[L]{\includegraphics[height=1.8cm]{Org-mode-unicorn.png}}
  \fancyhead[C]{
    Page: \thepage/\pageref{LastPage} \\
    \text{ } \\
    \text{ } \\
    DRAFT
  }
  \fancyhead[R]{\includegraphics[height=1.8cm]{Emacs-logo.png}}

  % Add fancy header and footer to custom titlepage.
  % https://tex.stackexchange.com/questions/506102/
  % adding-header-and-footer-to-custom-titlepage
  \fancypagestyle{titlepage}{%
    \fancyhf{}
    \renewcommand{\footrulewidth}{0.4pt}
    \fancyfoot[C]{\emph{
        Emacs setup for use with \LaTeX{}, Org, and Python -- Gerard Vermeulen}}
    \renewcommand{\headrulewidth}{0.4pt}
    \fancyhead[L]{\includegraphics[height=1.8cm]{Org-mode-unicorn.png}}
    \fancyhead[C]{
      \pageref{LastPage} pages \\
      \text{ } \\
      \text{ } \\
      DRAFT
    }
    \fancyhead[R]{\includegraphics[height=1.8cm]{Emacs-logo.png}}
  }
#+end_src

* Quick start
:PROPERTIES:
:CUSTOM_ID: sec:quick-start
:END:

Backup your =user-emacs-directory= (defaults often to =~/.emacs.d= on =Linux=,
=Unix=, or =Darwin=) directory and execute the commands in listing
[[lst:prepare-user-emacs-directory]].  After normal (interactive mode, no batch
mode, neither server mode), Emacs will ask you to install a selected set of
packages.  Quit Emacs and invoke Emacs again.

#+caption[Prepare the user-emacs-directory]:
#+caption: Clone and initialize the user-emacs-directory.
#+label: lst:prepare-user-emacs-directory
#+begin_src shell :noeval :tangle no
  cd ~
  git clone ccdr@mercury.grenoble.cnrs.fr:SERVER/emacs.d.git .emacs.d
  make --directory=.emacs.d init
  emacs &
#+end_src

* Introduction
:PROPERTIES:
:CUSTOM_ID: sec:introduction
:END:

This Emacs setup aims to install automatically a minimal set of extension
packages that allows to handle my reports and presentations.  The file format of
the reports is [[https://orgmode.org/][Org Mode]] plain text with [[https://www.python.org/][Python]] source code blocks and the file
format of the presentations is [[https://www.latex-project.org/][LaTeX]].

This [[info:org#Top][org]] file (more precisely the original [[info:org#Top][org]] source file of this file)
illustrates three methods in my work-flow:
1. How to tangle (or export) source blocks from [[info:org#Top][org]] files. This file contains
     source blocks to produce the files =early-init.el=, =init.el=, =latexmkrc=,
   =org-store-link=, and =example.py= by tangling.
2. How to export [[info:org#Top][org]] files to other formats such as [[https://en.wikipedia.org/wiki/HTML][HTML]], [[https://www.latex-project.org/][LaTeX]], and [[https://en.wikipedia.org/wiki/PDF][PDF]].
3. How [[info:org#Hyperlinks][org hyperlinks (info)]] allow to link inside and outside [[info:org#Top][Org Mode]]: hover
   over or click on the links to experiment.

The [[https://en.wikipedia.org/wiki/AUCTeX][AUCTeX - Aalborg University Center TeX]] extension package provides a
powerful [[https://en.wikipedia.org/wiki/Text-based_user_interface][Text-based User Interface (TUI)]] environment to edit the [[https://www.latex-project.org/][LaTeX]]
presentations.

The [[https://github.com/bdarcus/citar][citar]] extension package provides quick filtering and selecting of
bibliographic entries, and the option to run different commands on those
selections.  [[https://github.com/bdarcus/citar][Citar]] requires [[info:org#Top][Org-9.5 (info)]], which is already part of Emacs-28.1.
[[https://github.com/bdarcus/citar][Citar]] exploits the enhancements of Emacs' builtin selection mechanism provided
by the extension packages [[https://github.com/minad/vertico][vertico]], [[https://github.com/oantolin/orderless][orderless]], [[https://github.com/oantolin/embark][embark]], [[https://github.com/minad/marginalia][marginalia]], and [[https://github.com/minad/consult][consult]].
The [[https://github.com/andras-simonyi/citeproc-el][citeproc]] extension package provides [[https://citationstyles.org/][CSL: citation style language]] processing
capabilities to [[https://github.com/bdarcus/citar][citar]] and [[https://orgmode.org/][Org Mode]].

The [[https://github.com/vedang/pdf-tools][pdf-tools]] extension package renders [[https://en.wikipedia.org/wiki/PDF][PDF]] file with the possibility to
annotate the file or to click on anchors in the [[https://en.wikipedia.org/wiki/PDF][PDF]] file that link back to the
original [[https://www.latex-project.org/][LaTeX]] file of the document.  An example of my work-flow are the steps
to convert this [[info:org#Top][org]] file to [[https://en.wikipedia.org/wiki/PDF][PDF]] and to see the result with [[https://github.com/vedang/pdf-tools][pdf-tools]] in Emacs:
execute the commands ~pdf-tools-install~, ~org-babel-tangle~,
~org-latex-export-latex-to-latex~, and ~compile~.  This sets up an infinite
[[https://www.latex-project.org/][LaTeX]] compilation loop to update and redisplay the [[https://en.wikipedia.org/wiki/PDF][PDF]] file after excution of
the ~org-latex-export-latex-to-latex~ command in this buffer.

Here follows a list of interesting Emacs configurations:
1. [[https://github.com/alhassy/emacs.d][Musa Al-hassy's configuration]] is an impressive example of producing the Emacs
   initialization files and other files by tangling an [[info:org#Top][org]] file. His methodology
   is impressive, as his [[https://alhassy.github.io/ElispCheatSheet/][Elisp Cheat Sheet]] and [[https://alhassy.github.io/org-special-block-extras/][org-special-block-extra package]]
   show.  To me, this is a configuration to admire, but his methodology is way
   over my head.
2. [[https://github.com/oantolin/emacs-config][Omar Antolín Camarena's configuration]] exploits built-in packages, Omar's own
   small packages, and large external packages.  Omar is the author of [[https://github.com/oantolin/orderless][orderless]]
   and [[https://github.com/oantolin/embark][embark]].  I have stolen his idea of using ~custom-set-variables~.
3. [[https://gitlab.com/ambrevar/dotfiles][Pierre Neirhardt's configuration]] implements lazy loading without help of
   external packages.  I have stolen his approach of using lazy loading to
   silently ignore the setup stanzas of uninstalled extension packages.
4. [[https://sachachua.com/dotemacs/][Sacha Chua's configuration]] is a practical example of producing the Emacs
   initialization files by tangling an [[info:org#Top][org]] file.  It gives me the impression
   that she is a very practical person trying to achieve her goals by the most
   efficient means.  I have stolen her idea of using [[https://github.com/quelpa/quelpa][quelpa]] to install packages
   from any source.
5. [[https://github.com/purcell/emacs.d][Steve Purcell's configuration]] is well organized, a showcase of readable code,
   as well helpful commit and issue histories.  See for instance the discussion
   on [[https://github.com/purcell/emacs.d/issues/778][the correctness of order of company candidates in Emacs lisp mode]].
6. [[https://github.com/tecosaur/emacs-config][Timothy E. Chapman's configuration]]

* [[info:emacs#Early Init File][Early Init File (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:early-init-file
:END:

Try to load [[https://github.com/emacscollective/no-littering][no-littering]] as early as possible, since it helps to keep
=~/.emacs.d= clean.

#+caption[Tangle the early-init-file]:
#+caption: Tangle the early-init-file.
#+label: lst:tangle-early-init-file
#+begin_src emacs-lisp :tangle early-init.el
  ;;; early-init.el --- user early-init file        -*- lexical-binding: t -*-
  ;;; Commentary:
  ;;; Code:
  (setq load-prefer-newer t)

  (require 'no-littering nil 'noerror)

  (provide 'early-init)
  ;; Emacs looks for "Local variables:" after the last "?\n?\f".
  
  ;; Local Variables:
  ;; indent-tabs-mode: nil
  ;; End:
  ;;; earl-init.el ends here
#+end_src

In order to get help in understanding the code block above in a buffer showing
the original [[info:org#Top][Org]] source file, move point (or cursor) to one of the items of the
list the and type =C-c C-c=:
1. src_emacs-lisp{(describe-variable #'load-prefer-newer t)}
2. src_emacs-lisp{(apropos-library "no-littering")}
3. src_emacs-lisp{(find-function #'hack-local-variables)}
to execute the code between the curly braces for access to help.

This shows why *Emacs is a self-documenting editor.*

* [[info:emacs#Init File][Init File (info)]] header
:PROPERTIES:
:CUSTOM_ID: sec:init-file-header
:END:

The =user-init-file= header requires =cl-lib= and customizes Emacs variables.
It consists of three parts in listing [[lst:1st-custom-set-variables-call]],
[[lst:2nd-custom-set-variables-call]], and [[lst:3rd-custom-set-variables-call]] in
order to limit the length of the listings for exporting to LaTeX.  The [[info:elisp#Quoting][quoting
(info)]] and the [[info:elisp#Backquote][backquote (info)]] pages explain how to understand the reader
macros ~'~ (quote), ~`~ (backquote), ~,~ (substitute) and ~@,~ (splice) in the
~custom-set-variables~ function calls in listing
[[lst:1st-custom-set-variables-call]], [[lst:2nd-custom-set-variables-call]], and
[[lst:3rd-custom-set-variables-call]].  A tutorial of how to use those reader macros
is the [[https://mullikine.github.io/posts/macro-tutorial/][didactic emacs-lisp macro example]].  The [[info:emacs#Init File][init file (info)]] does not load
the ~custom-file~ as [[info:emacs#Saving Customizations][saving customizations (info)]] recommends because of the
~custom-set-variables~ function calls.

#+caption[Customize the first set of Emacs variables]:
#+caption: Customize the first set of Emacs variables.
#+label: lst:1st-custom-set-variables-call
#+begin_src emacs-lisp
  ;;; init.el --- user init file                    -*- lexical-binding: t -*-
  ;;; Commentary:
  ;;; Code:
  (require 'cl-lib)

  (custom-set-variables
   '(after-save-hook #'executable-make-buffer-file-executable-if-script-p)
   '(column-number-mode t)
   '(cursor-type 'box)
   `(custom-file ,(locate-user-emacs-file "custom.el"))
   '(epg-pinentry-mode 'loopback)
   '(global-hl-line-mode t)
   '(global-hl-line-sticky-flag t)
   '(indent-tabs-mode nil)
   '(inhibit-startup-buffer-menu t)
   '(inhibit-startup-screen t)
   '(initial-buffer-choice t)
   '(initial-scratch-message "")
   `(insert-directory-program ,(or (executable-find "gls")
                                   (executable-find "ls")))
   '(kill-ring-max 300)
   '(package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
                        ("nongnu" . "https://elpa.nongnu.org/nongnu/")
                        ("melpa" . "https://melpa.org/packages/"))))
#+end_src

#+caption[Customize the second set of Emacs variables]:
#+caption: Customize the second set of Emacs variables.
#+label: lst:2nd-custom-set-variables-call
#+begin_src emacs-lisp
  (custom-set-variables
   `(package-selected-packages
     `(,@(when (version< emacs-version "28.0")
           '(org))                ; plain text thought organizer
       anaconda-mode              ; strangles python-mode
       async                      ; asynchroneous processing
       auctex                     ; Aalborg University Center TeX
       blacken                    ; Black Python-code formatter client
       citar                      ; bibliography handling
       citeproc                   ; bibliography handling
       company                    ; complete anything
       company-anaconda           ; complete anything in anaconda-mode
       consult                    ; consult completing-read
       eglot                      ; Emacs polyGLOT LSP client
       electric-operator          ; automatic spacing around operators
       elfeed                     ; web feed reader
       embark                     ; act on any buffer selection
       emms                       ; Emacs Multi-Media System
       htmlize                    ; convert buffer contents to HTML
       iedit                      ; simultaneous multi-entity editing
       laas                       ; LaTeX Auto-Activating Snippets
       leuven-theme               ; beautiful color theme
       magit                      ; Git Text-based User Interface
       marginalia                 ; minibuffer margin notes
       markdown-mode              ; markdown text mode
       no-littering               ; keep `user-emacs-directory' clean
       nov                        ; EPUB reader
       orderless                  ; Emacs completion style
       pdf-tools                  ; interactive docview replacement
       pdf-view-restore           ; add view history to pdf-tools
       pyenv-mode                 ; Python environment selector
       quelpa                     ; install Emacs packages from source
       rainbow-mode               ; set background color to color string
       smartparens                ; smart editing of character pairs
       toml-mode                  ; Tom's Obvious Minimal Language mode
       vertico                    ; VERTical Interactive Completion
       wgrep                      ; open a writable grep buffer
       which-key                  ; on the fly key-binding help
       wordnut                    ; WordNet lexical database
       writegood-mode             ; bullshit and weasel-word detector
       ws-butler                  ; remove trailing whitespace
       xr                         ; undo rx to grok regular expressions
       yasnippet)))               ; code or text template expansion
#+end_src

#+caption[Customize the third set of Emacs variables]:
#+caption: Customize the third set of Emacs variables.
#+label: lst:3rd-custom-set-variables-call
#+begin_src emacs-lisp
  (custom-set-variables
   '(recentf-mode t)
   '(save-place-mode t)
   '(scroll-bar-mode nil)
   '(tab-always-indent 'complete)
   '(tab-width 8)
   '(tool-bar-mode nil)
   '(url-cookie-trusted-urls nil)
   '(url-cookie-untrusted-urls '(".*"))
   '(use-dialog-box nil)
   '(use-short-answer t)
   '(view-read-only t))

  (when (eq system-type 'darwin)
    (custom-set-variables
     '(ns-alternate-modifier nil)
     '(ns-command-modifier 'meta)
     '(ns-right-command-modifier 'super)))

  (when (eq window-system 'ns)
    (add-to-list 'initial-frame-alist '(height . 51))
    (add-to-list 'initial-frame-alist '(width . 180)))
#+end_src

* Install the selected packages
:PROPERTIES:
:CUSTOM_ID: sec:install-selected-packages
:END:

[[info:emacs#Package Installation][Emacs installs packages]] from archives on the internet.  This setup uses three
archives:
1. The [[https://elpa.gnu.org/][GNU Emacs Lisp Package Archive]]
2. The [[https://elpa.nongnu.org/][NonGNU Emacs Lisp Package Archive]].
3. The [[https://melpa.org/#/][Milkypostman’s Emacs Lisp Package Archive (MELPA)]].
Finally, the [[https://github.com/quelpa/quelpa][quelpa]] tool allows to fetch code from any source and build a
package on your computer before installation.

The code in listing [[lst:install-selected-packages]] assumes that the package
system is in a *virgin* state in case the package [[https://github.com/emacscollective/no-littering][no-littering]] is not present.
Refreshing the contents of available packages at least once is a requirement in
order to be able to install and load any packages, hence also [[https://github.com/emacscollective/no-littering][no-littering]].

The call src_emacs-lisp{(package-install-selected-packages)} checks the
installation status of all packages in src_emacs-lisp{package-selected-packages}
and installs the missing packages after the user has agreed to its prompt.  In
case of normal Emacs usage, src_emacs-lisp{(package-list-packages)} refreshes
the contents of packages and allows to update packages to the latest version.

#+caption[Install the selected packages]:
#+caption: Install the selected packages.
#+label: lst:install-selected-packages
#+begin_src emacs-lisp
  (unless (require 'no-littering nil 'noerror)
    (package-refresh-contents)
    (package-install 'no-littering)
    (require 'no-littering))

  (unless noninteractive
    (package-install-selected-packages))
#+end_src

* [[info:emacs#Emacs Server][Using Emacs as a server (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:using-emacs-server
:END:

Emacs can act as a server that listens to a socket to share its state (for
instance buffers and command history) with other programs by means of a shell
command =emacsclient=.  Section [[#sec:latexmk-save-compile-display-loop]] and
[[#sec:qutebrowser-userscript]] show how to use ~emacsclient~ to:
1. Install an asynchronous (or background) loop of saving a LaTeX file,
   compiling it, and redisplaying the output in Emacs.
2. Make [[https://qutebrowser.org][qutebrowser]] send html links with document titles to Emacs.
The code in listing [[lst:start-emacs-server]] starts the Emacs server.

#+caption[Start the Emacs server]:
#+caption: Start the Emacs server.
#+label: lst:start-emacs-server
#+begin_src emacs-lisp
  (when window-system
    (unless (or noninteractive (daemonp))
      (add-hook 'after-init-hook #'server-start)))
#+end_src

** Latexmk save-compile-display loop
:PROPERTIES:
:CUSTOM_ID: sec:latexmk-save-compile-display-loop
:END:

The =latexmk= resource file in the next source code block shows how to use
=emacsclient= to (re)display the PDF file in Emacs after each succesful
(re)compilation on condition that the settings of the ~compile-command~ local
variable in section are compatible.  The local variable ~compile-command~ in the
[[#sec:local-variables][local variables]] section (only visible in =org= files, but not in =html= and
=pdf= files) shows how to use the =latexmkrc= file.

#+caption[Tangle the Latexmk resource file]:
#+caption: Tangle the Latexmk resource file.
#+label: lst:latexmkrc
#+begin_src perl :tangle latexmkrc :comments none
  # pdf previewer and update pdf previewer
  $pdf_previewer = "emacsclient -e '(find-file-other-window %S)'";
  $pdf_update_method = 4;  # 4 runs a command to force the update
  $pdf_update_command = "emacsclient -e '(with-current-buffer (find-buffer-visiting %S) (pdf-view-revert-buffer nil t))'";
  # see for instance glossary.latexmkrc
  add_cus_dep( 'acn', 'acr', 0, 'makeglossaries' );
  add_cus_dep( 'glo', 'gls', 0, 'makeglossaries' );
  $clean_ext .= " acr acn alg bbl glo gls glg ist lol run.xml";
  sub makeglossaries {
      my ($name, $path) = fileparse( $$Psource );
      return system "makeglossaries -d '$path' '$name'";
  }
  # Emacs looks for "Local variables:" after the last "?\n?\f".
  
  # Local Variables:
  # mode: perl
  # End:
#+end_src

** [[https://qutebrowser.org/doc/userscripts.html][Qutebrowser userscript]]
:PROPERTIES:
:CUSTOM_ID: sec:qutebrowser-userscript
:END:

The next block contains an userscript that sends a [[info:org#The store-link protocol][store-link org-protocol]]
message with the url and the title from [[https://qutebrowser.org][qutebrowser]] to =emacsclient=.  The
function =urlencode= translates the url and the title for the message. The
[[info:python#Examples<22>][Python urllib examples]] show how to use =urlencode=.  The final =execvp= call
deals with a [[https://qutebrowser.org][qutebrowser]] userscript requirement: the =emacsclient= process must
get the PID of the userscript that must kill itself after the take-over.
Termination of the =emacsclient= process hands control back to [[https://qutebrowser.org][qutebrowser]].

On a [[https://en.wikipedia.org/wiki/POSIX][POSIX]] system, you can run the userscript from [[https://qutebrowser.org][qutebrowser]] or from a
terminal to see whether it works.  In case you try to run it from Emacs, Emacs
may hang or die.

#+caption[Tangle a qutebrowser userscript]:
#+caption: Tangle a qutebrowser userscript.
#+header: :comments none
#+header: :tangle-mode (identity #o755)
#+label: lst:qutebrowser-userscript
#+begin_src python :noeval :tangle org-store-link
  #!/usr/bin/env python
  from urllib.parse import urlencode
  from os import environ, execvp

  url = environ.get("QUTE_URL", "https://orgmode.org")
  title = environ.get("QUTE_TITLE", "Org Mode")
  parameters = urlencode({"url": url, "title": title})
  print(payload := f"org-protocol://store-link?{parameters}")
  execvp("emacsclient", ("-n", payload))
#+end_src

** TODO Look into: org-protocol handling with other browser on Darwin
1. [[http://rwx.io/posts/osx-uri-protocol-handler/][Patrick Goddi: macOS URI protocol handler]] and his [[https://github.com/fooqri/uri-handler][URI-Handler]].
2. [[https://www.hammerspoon.org/][Hammerspoon]]
3. [[https://vritser.github.io/posts/capture-anywhere/][Emacs Capture Anywhere]]

* Completion
:PROPERTIES:
:CUSTOM_ID: sec:completion
:END:

[[info:vertico#Top][Vertico (info)]] provides a performant and minimalistic vertical completion UI
based on the default completion system and behaves therefore correctly under all
circumstances.  [[https://cestlaz.github.io/post/using-emacs-80-vertico/][Using Vertico, Marginalia, Consult, and Embark]] links to a video
demonstration.  Vertico integrates well with fully supported complementary
packages to enrich the completion UI:
1. [[info:orderless#Top][Orderless (info)]] for an advanced completion style,
2. [[info:embark#Top][Embark (info)]] for minibuffer actions with context menus,
3. [[info:marginalia#Top][Marginalia (info)]] for rich annotations in the minibuffer, and
4. [[info:consult#Top][Consult (info)]] for useful search and navigation commands,
where the order is that of [[https://github.com/bdarcus/citar#installation][enhancing citar's experience]] and the configuration
steps below.

Finally, [[https://company-mode.github.io/][company: a modular complete-anything framework for Emacs]] provides
completion in any buffer and [[#sec:minibuffer-history-completion][minibuffer-history-completion]] provides completion
on previous input in the minibuffer.

** [[info:vertico#Top][Vertico (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:vertico-configuration
:END:

Listing [[lst:enable-vertico-mode]] configures and enables =savehist-mode= and
enables =vertico-mode=.  The documentation src_emacs-lisp{(describe-function
'savehist-mode)} why it is best to turn on =savehist-mode= in the Emacs init
file.

#+caption[Enable =savehist-mode= and =vertico-mode=]:
#+caption: Enable =savehist-mode= and =vertico-mode=.
#+label: lst:enable-vertico-mode
#+begin_src emacs-lisp
  (unless noninteractive
    (custom-set-variables
     '(history-delete-duplicates t)
     '(history-length 500)
     '(savehist-additional-variables
       '(eww-history
         kill-ring
         regexp-search-string
         search-ring
         search-string)))
    (savehist-mode +1)
    (when (fboundp 'vertico-mode)
      (vertico-mode +1)))
#+end_src

** [[info:orderless#Top][Orderless (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:orderless-configuration
:END:

Listing [[lst:configure-orderless]] enables =orderless=.

#+caption[Configure =orderless=]:
#+caption: Configure =orderless=.
#+label: lst:configure-orderless
#+begin_src emacs-lisp
  (unless noninteractive
    (when (fboundp 'orderless-filter)
      (custom-set-variables
       ;; https://github.com/purcell/emacs.d/issues/778
       '(completion-styles '(basic completion-partial orderless))
       '(completion-category-defaults nil)
       '(completion-category-overrides
         '((file (styles partial-completion)))))
      (add-hook 'minibuffer-setup-hook
                (defun my-on-minibuffer-setup-hook()
                  (setq-default completion-styles '(substring orderless))))))
#+end_src

**  [[info:embark#Top][Embark (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:embark-configuration
:END:

Listing [[lst:configure-embark]] configures =embark=.

#+caption[Configure =embark=]:
#+caption: Configure =embark=.
#+label: lst:configure-embark
#+begin_src emacs-lisp
  (unless noninteractive
    (when (cl-every #'fboundp '(embark-act embark-bindings embark-dwim))
      (global-set-key (kbd "C-,") #'embark-act)
      (global-set-key (kbd "C-:") #'embark-dwim)
      (global-set-key (kbd "C-h B") #'embark-bindings)))
#+end_src

** [[info:marginalia#Top][Marginalia (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:marginalia-configuration
:END:

Listing [[lst:enable-marginalia-mode]] enables =marginalia-mode=.

#+caption[Enable =marginalia-mode=]:
#+caption: Enable =marginalia-mode=.
#+label: lst:enable-marginalia-mode
#+begin_src emacs-lisp
  (unless noninteractive
    (when (fboundp 'marginalia-mode)
      (marginalia-mode +1)))
#+end_src

** [[info:consult#Top][Consult (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:consult-configuration
:END:

Listing [[lst:configure-consult]] configures =consult=.

#+caption[Configure =consult=]:
#+caption: Configure =consult=.
#+label: lst:configure-consult
#+begin_src emacs-lisp
  (unless noninteractive
    (when (fboundp 'consult-apropos)
      (custom-set-variables
       '(consult-project-root-function #'vc-root-dir))
      ;; C-c bindings (mode-specific-map)
      (global-set-key (kbd "C-c h") #'consult-history)
      (global-set-key (kbd "C-c m") #'consult-mode-command)
      ;; C-x bindings (ctl-x-map)
      (global-set-key (kbd "C-x M-:") #'consult-complex-command)
      (global-set-key (kbd "C-x b") #'consult-buffer)
      (global-set-key (kbd "C-x 4 b") #'consult-buffer-other-window)
      (global-set-key (kbd "C-x 5 b") #'consult-buffer-other-frame)
      (global-set-key (kbd "C-x r x") #'consult-register)
      (global-set-key (kbd "C-x r b") #'consult-bookmark)
      ;; M-g bindings (goto-map)
      (global-set-key (kbd "M-g g") #'consult-goto-line)
      (global-set-key (kbd "M-g M-g") #'consult-goto-line)
      (global-set-key (kbd "M-g o") #'consult-outline)
      (global-set-key (kbd "M-g m") #'consult-mark)
      (global-set-key (kbd "M-g k") #'consult-global-mark)
      (global-set-key (kbd "M-g i") #'consult-imenu-project)
      (global-set-key (kbd "M-g e") #'consult-error)
      ;; M-s bindings (search-map)
      (global-set-key (kbd "M-s g") #'consult-git-grep)
      (global-set-key (kbd "M-s f") #'consult-find)
      (global-set-key (kbd "M-s k") #'consult-keep-lines)
      (global-set-key (kbd "M-s l") #'consult-line)
      (global-set-key (kbd "M-s m") #'consult-multi-occur)
      (global-set-key (kbd "M-s u") #'consult-focus-lines)
      ;; Other bindings
      (global-set-key (kbd "M-y") #'consult-yank-pop)
      (global-set-key (kbd "<help> a") #'consult-apropos)
      ;; Tweak functions
      (advice-add 'completing-read-multiple
                  :override #'consult-completing-read-multiple)
      (fset 'multi-occur #'consult-multi-occur)))
#+end_src

** [[https://company-mode.github.io/][Company: a modular complete anything framework for Emacs]]
:PROPERTIES:
:CUSTOM_ID: sec:company-configuration
:END:

Listing [[lst:configure-company]] configures =company=.

#+caption[Configure =company=]:
#+caption: Configure =company=.
#+label: lst:configure-company
#+begin_src emacs-lisp
  (unless noninteractive
    (when (fboundp 'company-mode)
      (custom-set-variables
       ;; https://github.com/purcell/emacs.d/issues/778
       '(company-transformers '(company-sort-by-occurrence)))
      (dolist (hook '(LaTeX-mode-hook
                      org-mode-hook
                      emacs-lisp-mode-hook
                      lisp-interaction-mode-hook
                      python-mode-hook
                      ielm-mode-hook))
        (add-hook hook #'company-mode))))
#+end_src

** Minibuffer history completion
:PROPERTIES:
:CUSTOM_ID: sec:minibuffer-history-completion
:END:

See [[https://lists.gnu.org/archive/html/emacs-devel/2021-12/msg00802.html][Juri Linkov (Emacs Developer mailing list)]] for how to allow completion on
previous input in the minibuffer. Listing
[[lst:enable-minibuffer-history-completion]] enables minibuffer history completion.

#+caption[Enable =minibuffer-history-completion=]:
#+caption: Enable =minibuffer-history-completion=.
#+label: lst:enable-minibuffer-history-completion
#+begin_src emacs-lisp
  (defun minibuffer-setup-history-completions ()
    (unless (or minibuffer-completion-table minibuffer-completion-predicate)
      (setq-local minibuffer-completion-table
                  (symbol-value minibuffer-history-variable))))

  (add-hook 'minibuffer-setup-hook 'minibuffer-setup-history-completions)

  ;; Stolen from Emacs-28.1 for Emacs-27.2:
  (unless (fboundp 'minibuffer--completion-prompt-end)
    (defun minibuffer--completion-prompt-end ()
      (let ((end (minibuffer-prompt-end)))
        (if (< (point) end)
            (user-error "Can't complete in prompt")
          end))))

  ;; Adapted from ‘minibuffer-complete’:
  (defun my-minibuffer-complete-history ()
    "Allow minibuffer completion on previous input."
    (interactive)
    (completion-in-region (minibuffer--completion-prompt-end) (point-max)
                          (symbol-value minibuffer-history-variable)
                          nil))

  (define-key minibuffer-local-map [C-tab] 'my-minibuffer-complete-history)
#+end_src

** Prefix key-binding help
:PROPERTIES:
:CUSTOM_ID: sec:prefix-key-binding-help
:END:

Configure ~which-key-mode~ so that typing =C-h= after a prefix key displays all
keys available after the prefix key.  Listing [[lst:enable-which-key-mode]] enables
=which-key-mode=.

#+caption[Enable =which-key-mode=]:
#+caption: Enable =which-key-mode=.
#+label: lst:enable-which-key-mode
#+begin_src emacs-lisp
  (when (fboundp 'which-key-mode)
    (custom-set-variables
     '(which-key-idle-delay 10000)
     '(which-key-idle-secondary-delay 0.05)
     '(which-key-show-early-on-C-h t))
    (which-key-mode +1))
#+end_src

* Reading
:PROPERTIES:
:CUSTOM_ID: sec:reading
:END:

** Reading EPUB files
:PROPERTIES:
:CUSTOM_ID: sec:reading-epub-files
:END:

Listing [[lst:enable-nov-mode]] enables =nov-mode=.

#+caption[Enable =nov-mode=]:
#+caption: Enable =nov-mode=.
#+label: lst:enable-nov-mode
#+begin_src emacs-lisp
  (when (fboundp 'nov-mode)
    (add-to-list 'auto-mode-alist `(,(rx ".epub" eos) . nov-mode)))
#+end_src

** Reading PDF files
:PROPERTIES:
:CUSTOM_ID: sec:reading-pdf-files
:END:

The [[https://github.com/vedang/pdf-tools][pdf-tools]] package exploits the [[https://github.com/freedesktop/poppler][poppler]] library to render and to let you
annotate [[https://en.wikipedia.org/wiki/PDF][PDF]] files.  It also exploits the [[https://wiki.contextgarden.net/SyncTeX][SyncTeX]] library to link anchors in [[https://en.wikipedia.org/wiki/PDF][PDF]]
files produced with LaTeX to the original LaTeX sources.

In order to use [[https://github.com/vedang/pdf-tools][pdf-tools]], you have to type =M-x pdf-tools-install= after
installation of [[https://github.com/vedang/pdf-tools][pdf-tools]] from [[https://melpa.org/][MELPA]] or after each update of [[https://github.com/freedesktop/poppler][poppler]] to build or
rebuild the =epdfinfo= executable that serves the [[https://en.wikipedia.org/wiki/PDF][PDF]] files to Emacs.

#+caption[Enable =pdf-tools=]:
#+caption: Enable =pdf-tools=.
#+label: lst:enable-pdf-tools
#+begin_src emacs-lisp
  ;; 'pdf-loader-install' is the lazy equivalent of 'pdf-tools-install':
  ;; see the README file.
  (when (fboundp 'pdf-loader-install)
    (pdf-loader-install))

  (with-eval-after-load 'pdf-view
    (when (fboundp 'pdf-view-restore-mode)
      (add-hook 'pdf-view-mode-hook #'pdf-view-restore-mode)))
#+end_src

* Writing
:PROPERTIES:
:CUSTOM_ID: sec:writing
:END:

** Writing LaTeX files
:PROPERTIES:
:CUSTOM_ID: sec:writing-latex-files
:END:

Loading =tex.el= immediately instead of lazily ensures proper initialization of
[[https://en.wikipedia.org/wiki/AUCTeX][AUCTeX]].  For instance, the ~TeX-master~ safe local variable in the =tex.el=
elisp library file has no autoload cookie.  Without prior loading of =tex.el=,
Emacs will complain that ~TeX-master~ is no safe local variable in case it reads
a LaTeX file that sets ~TeX-master~.  Listing [[lst:require-auctex]] initializes
[[https://en.wikipedia.org/wiki/AUCTeX][AUCTeX]] properly.

#+caption[Require =AUCTeX=]:
#+caption: Require =AUCTeX=.
#+label: lst:require-auctex
#+begin_src emacs-lisp
  ;; Use `require' to make `TeX-master' a safe local variable.
  (when (require 'tex nil 'noerror)
    (custom-set-variables
     '(TeX-auto-save t)
     '(TeX-install-font-lock #'font-latex-setup)
     '(TeX-parse-self t)))
#+end_src

Although, the LaTeX =biblatex= is in use, listing [[lst:configure-bibtex]]
configures the Emacs =bibtex= library for the LaTeX =BiBTeX= package to maintain
backwards compatibility.

#+caption[Configure =bibtex=]:
#+caption: Configure =bibtex=.
#+label: lst:configure-bibtex
#+begin_src emacs-lisp
  (with-eval-after-load 'bibtex
    (custom-set-variables '(bibtex-dialect 'BibTeX)))
#+end_src

Listing [[lst:configure-font-latex]] disables font scaling of section titles.

#+caption[Configure =font-latex=]:
#+caption: Configure =font-latex=.
#+label: lst:configure-font-latex
#+begin_src emacs-lisp
  (with-eval-after-load 'font-latex
    (custom-set-variables
     '(font-latex-fontify-sectioning 1.0)))
#+end_src

Listing [[lst:configure-latex]] configures =latex= for a full featured
=LaTeX-section-command=.

#+caption[Configure =latex=]:
#+caption: Configure =latex=.
#+label: lst:configure-latex
#+begin_src emacs-lisp
  (with-eval-after-load 'latex
    (custom-set-variables
     '(LaTeX-section-hook '(LaTeX-section-heading
                            LaTeX-section-title
                            LaTeX-section-toc
                            LaTeX-section-section
                            LaTeX-section-label))))
#+end_src

Out of the box, [[https://en.wikipedia.org/wiki/AUCTeX][AUCTeX]] does not indent text between square brackets.  The code
in listing [[lst:configure-tex]] corrects this by advising to override
~TeX-brace-count-line~ with ~my-TeX-brace-count-line~.

#+caption[Configure =TeX=]:
#+caption: Configure =TeX=.
#+label: lst:configure-tex
#+begin_src emacs-lisp
  (with-eval-after-load 'tex
    ;; https://emacs.stackexchange.com/questions/17396/
    ;; indentation-in-square-brackets
    (defun my-TeX-brace-count-line ()
      "Count number of open/closed braces."
      (save-excursion
        (let ((count 0) (limit (line-end-position)) char)
          (while (progn
                   (skip-chars-forward "^{}[]\\\\" limit)
                   (when (and (< (point) limit) (not (TeX-in-comment)))
                     (setq char (char-after))
                     (forward-char)
                     (cond ((eq char ?\{)
                            (setq count (+ count TeX-brace-indent-level)))
                           ((eq char ?\})
                            (setq count (- count TeX-brace-indent-level)))
                           ((eq char ?\[)
                            (setq count (+ count TeX-brace-indent-level)))
                           ((eq char ?\])
                            (setq count (- count TeX-brace-indent-level)))
                           ((eq char ?\\)
                            (when (< (point) limit)
                              (forward-char) t))))))
          count)))
    (advice-add 'TeX-brace-count-line :override #'my-TeX-brace-count-line))
#+end_src

*** TODO Improve the AUCTeX configuration slowly
[[https://github.com/thisirs/dotemacs/blob/master/lisp/init-auctex.el][AUCTeX setup of an experienced user]]

** Writing Org files
:PROPERTIES:
:CUSTOM_ID: sec:writing-org-files
:END:

*** [[info:org#Activation][Org activation (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:activate-org
:END:

#+caption[Activate =Org=]:
#+caption: Activate =Org=.
#+label: lst:activate-org
#+begin_src emacs-lisp
  ;; Inspect:
  ;; function with "C-h f"
  ;; symbols with "C-h o"
  ;; variables with "C-h v"

  (global-set-key (kbd "C-c a") #'org-agenda)
  (global-set-key (kbd "C-c c") #'org-capture)
  (global-set-key (kbd "C-c l") #'org-store-link)
  (global-set-key (kbd "C-c C-l") #'org-insert-link-global)
#+end_src

*** Org customization
:PROPERTIES:
:CUSTOM_ID: sec:customize-org
:END:

The code in listing [[lst:customize-org-babel]], [[lst:customize-org]], and
[[lst:customize-org-export]] does basic customization of [[https://orgmode.org/][Org Mode]] variables.

#+caption[Customize =org-babel=]:
#+caption: Customize =org-babel=.
#+label: lst:customize-org-babel
#+begin_src emacs-lisp
  (with-eval-after-load 'ob-core
    (custom-set-variables
     '(org-confirm-babel-evaluate nil)))

  (with-eval-after-load 'ob-python
    (custom-set-variables
     '(org-babel-python-command "python -E")))
#+end_src

#+caption[Customize =Org=]:
#+caption: Customize =Org=.
#+label: lst:customize-org
#+begin_src emacs-lisp
  (with-eval-after-load 'org
    (custom-set-variables
     '(org-babel-load-languages '((C . t)
                                  (calc . t)
                                  (dot . t)
                                  (emacs-lisp . t)
                                  (eshell . t)
                                  (fortran . t)
                                  (gnuplot . t)
                                  (latex . t)
                                  (lisp . t)
                                  (maxima . t)
                                  (org . t)
                                  (perl . t)
                                  (python . t)
                                  (scheme . t)
                                  (shell . t)))
     '(org-file-apps '((auto-mode . emacs)
                       (directory . emacs)
                       ("\\.mm\\'" . default)
                       ("\\.x?html?\\'" . default)
                       ("\\.pdf\\'" . emacs)))
     '(org-modules '(ol-bibtex
                     ol-doi
                     ol-eww
                     ol-info
                     org-id
                     org-protocol
                     org-tempo))
     '(org-structure-template-alist '(("a" . "export ascii")
                                      ("c" . "center")
                                      ("C" . "comment")
                                      ("e" . "example")
                                      ("E" . "export")
                                      ("h" . "export html")
                                      ("l" . "export latex")
                                      ("q" . "quote")
                                      ("s" . "src")
                                      ("p" . "src python :session :async")
                                      ("v" . "verse")))))
#+end_src

#+caption[Customize =org-export=]:
#+caption: Customize =org-export=.
#+label: lst:customize-org-export
#+begin_src emacs-lisp
  (with-eval-after-load 'ox-latex
    (custom-set-variables
     '(org-latex-compiler "lualatex")
     '(org-latex-hyperref-template "\\hypersetup{
    pdfauthor={%a},
    pdftitle={%t},
    pdfkeywords={%k},
    pdfsubject={%d},
    pdfcreator={%c},
    pdflang={%L},
    citecolor=blue,
    colorlinks=true,
    filecolor=blue,
    hyperfootnotes=false,
    linkcolor=blue,
    unicode=true,
    urlcolor=blue,
  }\n")
     '(org-latex-listings 'minted)
     '(org-latex-minted-options '(("bgcolor" "LightGoldenrodYellow")))
     '(org-latex-logfiles-extensions '("blg" "lof" "log" "lot" "out" "toc"))
     '(org-latex-prefer-user-labels t)))
#+end_src

*** [[https://github.com/bdarcus/citar][Citar: citing bibliography]] with [[https://orgmode.org/][Org Mode]]
:PROPERTIES:
:CUSTOM_ID: sec:citing-bibliography
:END:

[[https://github.com/bdarcus/citar][Citar]] is a completing-read front-end to browse and act on BibTeX, BibLaTeX, as
well as CSL JSON bibliographic data with LaTeX, markdown, and org-cite editing
support.  In combination with vertico, orderless, embark, marginalia, and
consult, [[https://github.com/bdarcus/citar][Citar]] provides quick filtering and selecting of bibliographic entries
from the minibuffer, as well as the option to run different commands on those
selections.  Listing [[lst:configure-oc-cite+citar]] configures =org-cite=, =citar=,
and =org=.

#+caption[Configure =org-cite= with =citar=]:
#+caption: Configure =oc-cite= with =citar=.
#+label: lst:configure-oc-cite+citar
#+begin_src emacs-lisp
  (with-eval-after-load 'oc
    (require 'oc-biblatex)
    (require 'oc-csl)

    (custom-set-variables
     '(org-cite-export-processors '((latex biblatex)
                                    (t csl)))
     '(org-cite-global-bibliography '("~/VCS/research/refs.bib")))

    (when (require 'citar nil 'noerror)
      (custom-set-variables
       '(org-cite-activate-processor 'citar)
       '(org-cite-follow-processor 'citar)
       '(org-cite-insert-processor 'citar))))

  (with-eval-after-load 'org
    (when (require 'citar nil 'noerror)
      (custom-set-variables
       '(citar-bibliography '("~/VCS/research/refs.bib"))
       '(citar-file-extensions '("djvu" "pdf"))
       '(citar-library-paths '("~/VCS/research/papers/"))))

    (define-key org-mode-map (kbd "C-c b") 'org-cite-insert))
#+end_src

*** TODO Compare bibtex and biblatex
1. [[https://www.economics.utoronto.ca/osborne/latex/BIBTEX.HTM][Using bibtex: a short guide]]
2. [[https://www.tug.org/texlive//devsrc/Master/texmf-dist/doc/latex/biblatex/biblatex.pdf][The biblatex package]]
3. [[https://github.com/yuchenlin/rebiber][Rebiber: A tool for normalizing bibtex with official info]]
4. [[https://github.com/josephwright/biblatex-phys][A biblatex implementation of the AIP and APS bibliography style]]

*** [[info:org#Adding Hyperlink Types][Making Org hyperlink types (info)]]
:PROPERTIES:
:CUSTOM_ID: sec:making-org-hyperlink-types
:END:

The code in listing [[lst:define-org-link-types]] defines =org-link= types for
backwards compatibility with [[https://github.com/jkitchin/org-ref][org-ref]].

#+caption[Define =org-link= types]:
#+caption: Define =org-link= types.
#+label: lst:define-org-link-types
#+begin_src emacs-lisp
  (with-eval-after-load 'ol
    (org-link-set-parameters
     "ac*" :export (lambda (path _desc backend _info)
                     (pcase backend
                       (`latex (format "\\gls*{%s}" path))
                       (_ path))))
    (org-link-set-parameters
     "cite" :export (lambda (path _desc backend _info)
                      (pcase backend
                        (`latex (format "\\cite{%s}" path))
                        (_ path))))
    (org-link-set-parameters
     "eqref" :export (lambda (path _desc backend _info)
                       (pcase backend
                         (`latex (format "\\eqref{%s}" path))
                         (_ path))))
    (org-link-set-parameters
     "hyperlink" :export (lambda (path desc backend _info)
                           (pcase backend
                             (`latex (format "\\hyperlink{%s}{%s}" path desc))
                             (_ path))))
    (org-link-set-parameters
     "label" :export (lambda (path _desc backend _info)
                       (pcase backend
                         (`latex (format "\\label{%s}" path))
                         (_ path))))
    (org-link-set-parameters
     "ref" :export (lambda (path _desc backend _info)
                     (pcase backend
                       (`latex (format "\\ref{%s}" path))
                       (_ path)))))
#+end_src

Listing [[lst:emacs-lisp-setup-patch-ol-info]] patches the function =org-info-export=
and the constant ~org-info-other-documents~, to export the [[info:org#External Links][info: links (info)]] in
this document to =html= and LaTeX correctly.

#+caption[Patch =ol-info=]:
#+caption: Patch =ol-info=.
#+name: lst:emacs-lisp-setup-patch-ol-info
#+begin_src emacs-lisp
  (with-eval-after-load 'ol-info
    (defun org-info-export (path desc format)
      "Export an info link.
  See `org-link-parameters' for details about PATH, DESC and FORMAT."
      (let* ((parts (split-string path "#\\|::"))
             (manual (car parts))
             (node (or (nth 1 parts) "Top")))
        (pcase format
          (`html
           (format "<a href=\"%s#%s\">%s</a>"
                   (org-info-map-html-url manual)
                   (org-info--expand-node-name node)
                   (or desc path)))
          (`latex
           (format "\\href{%s\\#%s}{%s}"
                   (org-info-map-html-url manual)
                   (org-info--expand-node-name node)
                   (or desc path)))
          (`texinfo
           (let ((title (or desc "")))
             (format "@ref{%s,%s,,%s,}" node title manual)))
          (_ nil))))

    (make-variable-buffer-local 'org-info-emacs-documents)
    (setq org-info-emacs-documents (delete "org" org-info-emacs-documents))
    (make-variable-buffer-local 'org-info-other-documents)
    (setq org-info-other-documents
          (cl-union '(("consult" . "https://github.com/minad/consult")
                      ("embark" . "https://github.com/oantolin/embark")
                      ("marginalia" . "https://github.com/minad/marginalia")
                      ("org" . "https://orgmode.org/org.html")
                      ("orderless" . "https://github.com/oantolin/orderless")
                      ("vertico" . "https://github.com/minad/vertico"))
                    org-info-other-documents
                    :test #'equal)))
#+end_src

*** [[https://tecosaur.github.io/emacs-config/#translate-capital-keywords][Translate capital keywords (old) to lower case (new)]]
:PROPERTIES:
:CUSTOM_ID: sec:convert-upper-to-lower-case-keywords
:END:

#+caption[Convert upper to lower case keywords]:
#+caption: Convert upper to lower case keywords.
#+label: lst:convert-upper-to-lower-case-keywords
#+begin_src emacs-lisp
  (with-eval-after-load 'org
    (defun org-syntax-convert-keyword-case-to-lower ()
      "Convert all #+KEYWORDS to #+keywords."
      (interactive)
      (save-excursion
        (goto-char (point-min))
        (let ((count 0)
              (case-fold-search nil))
          (while (re-search-forward "^[ \t]*#\\+[A-Z_]+" nil t)
            (unless (s-matches-p "RESULTS" (match-string 0))
              (replace-match (downcase (match-string 0)) t)
              (setq count (1+ count))))
          (message "Replaced %d keywords" count)))))
#+end_src

*** Evaluate specific source blocks at load-time
:PROPERTIES:
:CUSTOM_ID: sec:load-time-specific-source-block-evaluation
:END:

#+caption[Evaluate specific source blocks at load-time]:
#+caption: Evaluate specific source blocks at load-time.
#+label: lst:load-time-specific-source-block-evaluation
#+begin_src emacs-lisp
  (defun my-org-eval-blocks-named (infix)
    "Evaluate all source blocks having INFIX in their name."
    (when (eq major-mode 'org-mode)
      (let ((blocks
             (org-element-map
                 (org-element-parse-buffer 'greater-element nil) 'src-block
               (lambda (block)
                 (let ((name (org-element-property :name block)))
                   (message "%s" name)
                   (when (and name (string-match-p infix name))
                     block))))))
        (dolist (block blocks)
          (goto-char (org-element-property :begin block))
          (org-babel-execute-src-block)))))

  ;; Emacs looks for "Local variables:" after the last "?\n?\f".
  (add-to-list 'safe-local-eval-forms
               '(apply 'my-org-eval-blocks-named '("emacs-lisp-setup")))
  (add-to-list 'safe-local-eval-forms
               '(apply 'my-org-eval-blocks-named '("python-setup")))
#+end_src

*** [[info:org#LaTeX header and sectioning][Easy LaTeX preamble editing]]
:PROPERTIES:
:CUSTOM_ID: sec:easy-latex-preamble-editing
:END:

There are at least two ways (new and old) to edit the LateX preamble
=latex_header= and =latex-extra_header= export options easily in LaTeX source or
export blocks.  This [[info:org#Top][Org (info)]] file uses the new way, but keeps the old way for
backwards compatibility.

The new way -- exploiting an idea of [[https://www.matem.unam.mx/~omar/][Omar Antolin Camarena]] -- is to code new
[[info:org#Editing Source Code][<LANGUAGE>-modes]] allowing to edit in LaTeX mode and to export to LaTeX code with
[[info:org#LaTeX specific export settings][correct LaTeX preamble export setting prefixes]].  Here, are links to three posts
exposing his idea:
1. [[https://www.reddit.com/r/orgmode/comments/7u2n0h/tip_for_defining_latex_macros_for_use_in_both/][Export LaTeX macros to LaTeX and HTML/MathJax preambles (reddit)]],
2. [[https://www.reddit.com/r/orgmode/comments/5bi6ku/tip_for_exporting_javascript_source_block_to/][Export JavaScript source blocks to script tags in HTML (reddit)]],
3. [[https://emacs.stackexchange.com/questions/28301/export-javascript-source-block-to-script-tag-in-html-when-exporting-org-file-to][Export JavaScript source blocks to script tags in HTML (SX)]].
Listing [[lst:emacs-lisp-setup-latex-header]] implements this way by means of two
new [[info:org#Editing Source Code][<LANGUAGE>-modes]]: =latex-header= and =latex-extra-header=.

#+caption[New =<LANGUAGE>-modes= to edit the LaTeX preamble easily]:
#+caption: Add =latex-header= and =latex-extra-header=  language modes to edit
#+caption: LaTeX preamble =latex_header= and =latex_extra_header= export options
#+caption: easily.
#+name: lst:emacs-lisp-setup-latex-header
#+begin_src emacs-lisp
  (with-eval-after-load 'org-src (defun prefix-all-lines (prefix body)
    (with-temp-buffer (insert body) (string-insert-rectangle (point-min)
    (point-max) prefix) (buffer-string)))

    (add-to-list 'org-src-lang-modes '("latex-header" . latex))

    (defvar org-babel-default-header-args:latex-header '((:results
      . "raw") (:exports . "results")))

    (defun org-babel-execute:latex-header (body _params)
      (prefix-all-lines "#+latex_header: " body))

    (add-to-list 'org-src-lang-modes '("latex-extra-header" . latex))

    (defvar org-babel-default-header-args:latex-extra-header '((:results
      . "raw") (:exports . "results")))

    (defun org-babel-execute:latex-extra-header (body _params)
      (prefix-all-lines "#+latex_extra_header: " body)))
#+end_src

The old way is to use a special export attribute as in the function
=org-latex-header-blocks-filter= in [[https://git.sr.ht/~bzg/org-contrib/tree/master/item/lisp/ox-extra.el][ox-extra.el]].  Apparently, nobody is using
this broken function (broken, since it relies on support only in org-mode before
=2014-11-11=).  Listing [[lst:org-latex-header-blocks-filter]] proposes a fix.

#+caption[Convert marked LaTeX export blocks to LaTeX header lines]:
#+caption: Convert marked LaTeX export blocks to LaTeX header lines.
#+name: lst:org-latex-header-blocks-filter
#+begin_src emacs-lisp
  (with-eval-after-load 'ox
    (defun org-latex-header-blocks-filter (backend)
      "Convert marked LaTeX export blocks to \"#+latex_header: \" lines.
  The marker is a line \"#+header: :header yes\" preceding the block.

  For instance, the LaTeX export block

  ,#+header: :header yes
  ,#+begin_export latex
  % This line converts to a LaTeX header line.
  ,#+end_export

  converts to

  \"#+latex_header: % This line converts to a LaTeX header line.\"."
      (when (org-export-derived-backend-p backend 'latex)
        (let ((blocks
               (org-element-map
                   (org-element-parse-buffer 'greater-element nil) 'export-block
                 (lambda (block)
                   (let ((type (org-element-property :type block))
                         (header (org-export-read-attribute :header block :header)))
                     (when (and (string= type "LATEX") (string= header "yes"))
                       block))))))
          (mapc (lambda (block)
                  ;; Set point to where to insert LaTeX header lines
                  ;; after deleting the block.
                  (goto-char (org-element-property :post-affiliated block))
                  (let ((lines
                         (split-string (org-element-property :value block) "\n")))
                    (delete-region (org-element-property :begin block)
                                   (org-element-property :end block))
                    (dolist (line lines)
                      (insert (concat "#+latex_header: "
                                      (replace-regexp-in-string "\\` *" "" line)
                                      "\n")))))
                ;; Reverse to go upwards to avoid wrecking the list of
                ;; block positions in the file that would occur in case
                ;; of going downwards.
                (reverse blocks))))))
#+end_src

[[https://emacs.stackexchange.com/questions/47347/customizing-org-latex-title-command-to-edit-title-page][How to customize =org-latex-title-command= only in this buffer]]

#+caption[Define =my-ox-latex-export-buffer-local-variables=]:
#+caption: Define =my-ox-latex-export-buffer-local-variables=.
#+name: lst:emacs-lisp-setup-defun
#+begin_src emacs-lisp
  (defun my-ox-latex-export-buffer-local-variables (title-page)
    (with-eval-after-load 'ox
      (make-variable-buffer-local 'org-export-before-parsing-hook)
      (cl-pushnew #'org-latex-header-blocks-filter
                  org-export-before-parsing-hook))
    (when (require 'ox-latex nil 'noerror)
      (make-variable-buffer-local 'org-latex-classes)
      (cl-pushnew '("article-local"
                    "\\documentclass[11pt]{article}
  [NO-DEFAULT-PACKAGES]
  [PACKAGES]
  [EXTRA]"
                    ("\\section{%s}" . "\\section*{%s}")
                    ("\\subsection{%s}" . "\\subsection*{%s}")
                    ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                    ("\\paragraph{%s}" . "\\paragraph*{%s}")
                    ("\\subparagraph{%s}" . "\\subparagraph*{%s}"))
                  org-latex-classes :key #'car :test #'equal)

      (make-variable-buffer-local 'org-latex-title-command)
      (setq org-latex-title-command (concat title-page))

      (make-variable-buffer-local 'org-latex-toc-command)
      (setq org-latex-toc-command
            (mapconcat 'identity '(""
                                   "\\tableofcontents\\label{toc}"
                                   "\\listoffigures"
                                   "\\listoflistings"
                                   "\\listoftables"
                                   "\\newpage"
                                   "") "\n"))

      (make-variable-buffer-local 'org-latex-subtitle-format)
      (setq org-latex-subtitle-format "")))
#+end_src

[[lst:emacs-lisp-setup-call]]

#+caption[Call =my-ox-latex-export-local-variables=]:
#+caption: Use the setup macro for =ox-latex=.
#+name: lst:emacs-lisp-setup-call
#+header: :var title-page=title-page
#+begin_src emacs-lisp :exports code :results silent :tangle no
  (my-ox-latex-export-buffer-local-variables title-page)
#+end_src

#+caption[Show a title-page example for =org-latex-title-command=]:
#+caption: Show a title-page example for =org-latex-title-command=.
#+label: lst:title-page
#+name: title-page
#+begin_src latex :exports code :results silent :tangle no
  \begin{titlepage}
    %% https://tex.stackexchange.com/questions/506102/
    %% adding-header-and-footer-to-custom-titlepage
    \thispagestyle{titlepage}
    \begin{center}
      %% Title
      \begin{Huge}
        {\bf %t} \\
        \vspace{1em}
      \end{Huge}
      %% Author
      \begin{Large}
        {\bf %a} \\
        \vspace{1em}
      \end{Large}
    \end{center}
  \end{titlepage}
#+end_src

* Editing

** [[https://www.emacswiki.org/emacs/DisabledCommands][Enable disabled commands and inform]]
:PROPERTIES:
:CUSTOM_ID: sec:enable-disabled-commands
:END:

Execute src_emacs-lisp{(find-library "novice")} to see how Emacs prevents new
users from shooting themselves in the feet.

#+caption[Configure the =disabled-command-function=]:
#+caption: Configure the =disabled-command-function=.
#+label: lst:configure-disabled-command-function
#+begin_src emacs-lisp
  (setq disabled-command-function
        (defun my-enable-this-command (&rest _args)
          "Called when a disabled command is executed.
  Enable it and re-execute it."
          (put this-command 'disabled nil)
          (message "You typed %s.  %s was disabled until now."
                   (key-description (this-command-keys)) this-command)
          (sit-for 0)
          (call-interactively this-command)))
#+end_src

** [[info:emacs#Narrowing][Narrowing]]
:PROPERTIES:
:CUSTOM_ID: sec:narrowing
:END:

Narrowing means focusing in on some portion of the buffer and widening means
focussing out on the whole buffer.  This allows to concentrate temporarily on
for instance a particular function or paragraph by removing clutter. The "Do
What I Mean" [[https://endlessparentheses.com/emacs-narrow-or-widen-dwim.html][narrow-or-widen-dwim]] function allows to toggle between narrowed and
widened buffer states.

#+caption[Configure =narrow-or-widen-dwim=]:
#+caption: Configure =narrow-or-widen-dwim=.
#+label: lst:configure-narrow-or-widen-dwim
#+begin_src emacs-lisp
  (defun narrow-or-widen-dwim (p)
    "Widen if buffer is narrowed, narrow-dwim otherwise.
  Dwim means: region, org-src-block, org-subtree, or defun,
  whichever applies first. Narrowing to org-src-block actually
  calls `org-edit-src-code'.
  With prefix P, don't widen, just narrow even if buffer is
  already narrowed."
    (interactive "P")
    (declare (interactive-only))
    (cond ((and (buffer-narrowed-p) (not p)) (widen))
          ((and (bound-and-true-p org-src-mode) (not p))
           (org-edit-src-exit))
          ((region-active-p)
           (narrow-to-region (region-beginning) (region-end)))
          ((derived-mode-p 'org-mode)
           (or (ignore-errors (org-edit-src-code))
               (ignore-errors (org-narrow-to-block))
               (org-narrow-to-subtree)))
          ((derived-mode-p 'latex-mode)
           (LaTeX-narrow-to-environment))
          ((derived-mode-p 'tex-mode)
           (TeX-narrow-to-group))
          (t (narrow-to-defun))))

  (define-key ctl-x-map (kbd "C-n") #'narrow-or-widen-dwim)
#+end_src

** Synchronal multiple-region editing

#+caption[Enable =iedit=]:
#+caption: Enable =iedit=.
#+label: lst:enable-iedit
#+begin_src emacs-lisp
  (unless noninteractive
    (require 'iedit nil 'noerror))
#+end_src

** Extraneous whitespace trimming

#+caption[Configure =ws-butler=]:
#+caption: Configure =ws-butler=.
#+label: lst:configure-ws-butler
#+begin_src emacs-lisp
  (unless noninteractive
    (when (require 'ws-butler nil 'noerror)
      (custom-set-variables
       '(ws-butler-keep-whitespace-before-point nil))
      (add-hook 'prog-mode-hook #'ws-butler-mode)
      (add-hook 'text-mode-hook #'ws-butler-mode)))
#+end_src

** Structure editing
:PROPERTIES:
:CUSTOM_ID: sec:structure-editing
:END:

Structure editing keeps character pairs (for instance parentheses, curly and
square brackets as well as single and double quotes) balanced to leave code (for
instance Lisp and Python) and text (for instance LaTeX and Org) structure
intact.  I use [[https://github.com/Fuco1/smartparens][smartparens]] which offers a normal mode (=smartparens-mode=) and a
a strict mode (=smartparens-strict-mode=).  Although both modes insert character
pairs, the normal mode allows to easily delete one of the paired characters
while the strict mode does not.  Therefore, the strict mode is more for code
editing since it never breaks programming language rules and the normal mode is
more for text editing where structure is a matter of convention instead of
programming language rules.

For instance, the strict mode in Python allows to delete entire lists, tuples,
or the arguments after the cursor (what Emacs calls =point=) in a function call
without breaking the character pair balance.  In order to repair a broken
character pair balance, insert a single character by prefixing it with "C-q"
bound to =quoted-insert=.

The [[https://smartparens.readthedocs.io/en/latest/index.html][smartparens documentation]] targets experienced Emacs users.  The
following links show how to put the documentation to practical use:
1. [[https://gist.github.com/oantolin][Omar Antolin's gist "my-smartparens-config.el"]] is the first place to look for
   how to tweak [[https://github.com/Fuco1/smartparens][smartparens]].  However, the gist may be partially obsolete, since
   it is not part of his current [[https://github.com/oantolin/emacs-config][Emacs configuration]].
2. [[https://lists.gnu.org/archive/html/help-gnu-emacs/2014-07/msg00135.html][How to enable smartparens in the minibuffer after eval-expression]] explains
   how the machinery after the first and after later usages of =eval-expression=
   differ and discusses options how to handle those differences.

Listing [[lst:configure-smartparens]] aims to configure [[https://github.com/Fuco1/smartparens][smartparens]] for Elisp,
LaTeX, Org, and Python.

#+caption[Configure =smartparens=]:
#+caption: Configure =smartparens=.
#+label: lst:configure-smartparens
#+begin_src emacs-lisp
  (unless noninteractive
    ;; To disables pairing of the quote character for lisp modes,
    ;; require smartparens-config instead of smartparens.
    (when (require 'smartparens-config nil 'noerror)
      (custom-set-variables
       '(sp-base-key-bindings 'sp)
       '(sp-override-key-bindings '(("C-(" . sp-backward-barf-sexp)
                                    ("C-)" . sp-forward-slurp-sexp))))

      (dolist (hook '(prog-mode-hook
                      text-mode-hook))
        (add-hook hook #'smartparens-mode))

      ;; Hook on the specific `eval-expression-minibuffer-setup-hook'
      ;; and not on the general `minibuffer-setup-hook'.
      (dolist (hook '(emacs-lisp-mode-hook
                      eval-expression-minibuffer-setup-hook
                      ielm-mode-hook
                      inferior-emacs-lisp-mode-hook
                      python-mode-hook))
        (add-hook hook #'smartparens-strict-mode))

      ;; Tweak for the call to `smartparens-strict-mode' hooked on
      ;; `eval-expression-minibuffer-setup-hook'.
      (sp-with-modes '(fundamental-mode           ; first usage.
                       minibuffer-inactive-mode)  ; later usage.
        (sp-local-pair "'" nil :actions nil))

      ;; https://xenodium.com/emacs-smartparens-auto-indent/index.html
      (defun indent-between-pair (&rest _ignored)
        (newline)
        (indent-according-to-mode)
        (forward-line -1)
        (indent-according-to-mode))

      (sp-local-pair 'prog-mode "(" nil :post-handlers '((indent-between-pair "RET")))
      (sp-local-pair 'prog-mode "[" nil :post-handlers '((indent-between-pair "RET")))
      (sp-local-pair 'prog-mode "{" nil :post-handlers '((indent-between-pair "RET")))

      (show-smartparens-global-mode +1)))
#+end_src

** Electric operators
:PROPERTIES:
:CUSTOM_ID: sec:electric-operators
:END:

#+caption[Configure =electric-operator-mode=]:
#+caption: Configure =electric-operator-mode=.
#+label: lst:configure-electric-operator-mode
#+begin_src emacs-lisp
  (when (fboundp 'electric-operator-mode)
    (add-hook 'c-mode-common #'electric-operator-mode)
    (add-hook 'python-mode-hook #'electric-operator-mode))
#+end_src

** Smart snippets
:PROPERTIES:
:CUSTOM_ID: sec:smart-snippets
:END:

#+caption[Enable =yas-global-mode=]:
#+caption: Enable =yas-global-mode=.
#+label: lst:enable-yas-global-mode
#+begin_src emacs-lisp
  (when (require 'yasnippet nil 'noerror)
    (custom-set-variables
     '(yas-alias-to-yas/prefix-p nil))
    (yas-global-mode +1))
#+end_src

* Coding
:PROPERTIES:
:CUSTOM_ID: sec:coding
:END:

** Emacs-lisp coding
:PROPERTIES:
:CUSTOM_ID: sec:emacs-lisp-coding
:END:

** Python coding
:PROPERTIES:
:CUSTOM_ID: sec:python-coding
:END:

The [[https://www.emacswiki.org/emacs/PythonProgrammingInEmacs][Python Programming in Emacs]] wiki page lists options to enhance Emacs's
built-in ~python-mode~. Here, the focus is on two packages:
1. [[https://github.com/joaotavora/eglot][Eglot - Emacs polyGLOT: an Emacs LSP client that stays out of your way]].  The
   maintainer also contributes to Emacs itself and has a deep understanding of
   [[https://sheer.tj/the_way_of_emacs.html][the Way of Emacs]].  He refuses to add new features without seeing how they fit
   into [[https://sheer.tj/the_way_of_emacs.html][the Way of Emacs]] as this discussion on [[https://github.com/joaotavora/eglot/issues/523][org-mode source code blocks]]
   shows.
2. [[https://github.com/pythonic-emacs/anaconda-mode][Anaconda - code navigation, documentation lookup, and completion for Python]].
In my opinion, [[https://github.com/joaotavora/eglot][eglot]] has more potential than [[https://github.com/pythonic-emacs/anaconda-mode][anaconda]], but [[https://github.com/pythonic-emacs/anaconda-mode][anaconda]] is
compatible with [[info:org#Editing Source Code][source code block editing]] while [[https://github.com/joaotavora/eglot][eglot]] is not.  Listing
[[lst:configure-python]] configures [[https://www.python.org][Python]].

#+caption[Configure =python=]:
#+caption: Configure =python=.
#+name: lst:configure-python
#+begin_src elisp
  (with-eval-after-load 'python
    (custom-set-variables
     '(python-indent-guess-indent-offset nil)
     '(python-shell-interpreter-args "-i -E")))
#+end_src

Listing [[lst:configure-eglot-for-python]] configures [[https://github.com/joaotavora/eglot][eglot]] for [[https://www.python.org][Python]].  It may be a
good idea to launch [[https://github.com/joaotavora/eglot][eglot]] by means of [[info:emacs#Directory Variables][directory variables]] in the root directory
of any [[https://www.python.org][Python]] project.  Listing [[lst:eglot-directory-variables-for-python]] does a
proposal.

#+caption[Configure =eglot= for Python]:
#+caption: Configure =eglot= for Python.
#+name: lst:configure-eglot-for-python
#+begin_src emacs-lisp
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs '(python-mode "pylsp"))
    (setq-default
     eglot-workspace-configuration
     `((:pylsp . (:plugins (:jedi_completion
                            (:cache_for ,(vconcat '("astropy"
                                                    "numpy"
                                                    "scipy"))))))
       (:pylsp . (:plugins (:jedi_completion (:eager nil)))))))
#+end_src

#+caption[Propose =directory-variables= to launch =eglot=]:
#+caption: Propose =directory-variables= in the root of any Python project to
#+caption: launch =eglot=.
#+name: lst:eglot-directory-variables-for-python
#+begin_src emacs-lisp :tangle no
  ;; Proposal for a .dir-locals.el file in the root of any Python project.
  ((python-mode
    . ((eglot-workspace-configuration
        . `((:pylsp . (:plugins (:jedi_completion
                                 (:cache_for ,(vconcat '("astropy"
                                                         "numpy"
                                                         "scipy"))))))
            (:pylsp . (:plugins (:jedi_completion (:eager nil)))))))))
#+end_src

Listing [[lst:configure-anaconda-for-python]] configures [[https://github.com/pythonic-emacs/anaconda-mode][anaconda]]. See
[[https://github.com/jorgenschaefer/elpy/blob/8d0de310d41ebf06b22321a8534546447456870c/elpy.el#L2775][elpy-module-company]] for how to handle ~company-backends~ as a local variable and
the call to [[info:elisp#Advising Functions][advice-add]] opens Python org-mode edit-buffers in ~anaconda-mode~.

#+caption[Configure =anaconda= for Python]:
#+caption: Configure =anaconda= for Python.
#+name: lst:configure-anaconda-for-python
#+begin_src emacs-lisp
  (with-eval-after-load 'python
    (with-eval-after-load 'company
      (when (and (fboundp 'anaconda-mode)
                 (fboundp 'company-anaconda))
        (defun my-disable-anaconda-mode ()
          (when (derived-mode-p 'python-mode)
            (anaconda-mode -1)
            (make-variable-buffer-local 'company-backends)
            (setq company-backends
                  (delq 'company-anaconda
                        (mapcar #'identity company-backends)))
            (anaconda-eldoc-mode -1)))
        (defun my-enable-anaconda-mode ()
          (when (derived-mode-p 'python-mode)
            (anaconda-mode +1)
            (make-variable-buffer-local 'company-backends)
            (setq company-backends
                  (cons 'company-anaconda
                        (delq 'company-semantic
                              (delq 'company-capf
                                    (mapcar #'identity company-backends)))))
            (anaconda-eldoc-mode
             (if (file-remote-p default-directory) -1 1))))))

    (unless (and (fboundp 'my-disable-anaconda-mode)
                 (fboundp 'my-enable-anaconda-mode))
      (when (fboundp 'anaconda-mode)
        (defun my-disable-anaconda-mode ()
          (when (derived-mode-p 'python-mode)
            (anaconda-mode -1)
            (anaconda-eldoc-mode -1)))
        (defun my-enable-anaconda-mode ()
          (when (derived-mode-p 'python-mode)
            (anaconda-mode +1)
            (anaconda-eldoc-mode
             (if (file-remote-p default-directory) -1 1))))))

    (when (fboundp 'my-enable-anaconda-mode)
      (advice-add 'org-edit-src-code :after #'my-enable-anaconda-mode))
    (when (and (fboundp 'my-disable-anaconda-mode)
               (fboundp 'my-enable-anaconda-mode))
      (defun my-toggle-anaconda-mode ()
        "Toggle anaconda-mode with bells and whistles."
        (interactive)
        (if (bound-and-true-p anaconda-mode)
            (my-disable-anaconda-mode)
          (my-enable-anaconda-mode)))))
#+end_src

Listing [[lst:example-py]] is a [[https://www.python.org][Python]] example showing differences in the handling
of compiled foreign language modules and pure [[https://www.python.org][Python]] modules.  The underlying
[[https://jedi.readthedocs.io/en/latest/][jedi]] library parses modules (instead of imports) in order to handle completion
and documentation request.  Therefore, [[https://jedi.readthedocs.io/en/latest/][jedi]] and consequently [[https://github.com/joaotavora/eglot][eglot]] as well as
[[https://github.com/pythonic-emacs/anaconda-mode][anaconda]] treat compiled foreign language modules as second zone citizens.  This
is noticible when coding certain functions of for instance [[https://numpy.org/][numpy]] and [[https://scipy.org/][scipy]].

#+caption[Tangle the =example.py= file]:
#+caption: Tangle the =example.py= file.
#+name: lst:example-py
#+begin_src python :tangle example.py :comments link
  import numpy
  import astropy.units as apu

  a = numpy.arange(0, 11)
  a = numpy.linspace(0, 10, num=11)
  q = apu.Quantity(a, apu.meter)
  print(q)
#+end_src

Listing [[lst:enable-pyenv-mode]] configures and enables =pyenv-mode=.

#+caption[Enable =pyenv-mode=]:
#+caption: Enable =pyenv-mode=.
#+name: lst:enable-pyenv-mode
#+begin_src emacs-lisp
  (when (and (executable-find "pyenv")
             (require 'pyenv-mode nil 'noerror))
    (pyenv-mode +1)
    (pyenv-mode-set "3.9.9/envs/python-3.9.9"))
#+end_src

Listing [[lst:configure-info]] adds a path in my home directory to the places where
=info= looks for files.

#+caption[Configure =info=]:
#+caption: Configure =info=.
#+name: lst:configure-info
#+begin_src emacs-lisp
  (with-eval-after-load 'info
    (add-to-list 'Info-directory-list
                 (expand-file-name "~/.local/share/info")))
#+end_src

Look into:
1. [[https://github.com/douglasdavis/numpydoc.el/blob/main/numpydoc.el][Emacs extension to insert numpy style docstrings in function definitions]]

* Appearance

See the [[https://protesilaos.com/codelog/2020-09-05-emacs-note-mixed-font-heights/][note on mixed font heights in Emacs]] for how to setup fonts properly.  It
boils down to two rules:
1. The height of the default face must be an integer number to make the height a
   physical quantity.
2. The heights of all other faces must be real numbers to scale those heights
   with respect to the height of the face (those heights default to 1.0 for no
   scaling).

The code in listing [[lst:configure-face-attributes]] source implements those rules.

#+caption[Configure =face-attributse=]:
#+caption: Configure =face-attributes=.
#+label: lst:configure-face-attributes
#+begin_src emacs-lisp
  (unless noninteractive
    ;; Set face attributes.
    (cond
     ((eq system-type 'darwin)
      (set-face-attribute 'default nil :family "Hack" :height 120)
      (set-face-attribute 'fixed-pitch nil :family "Hack")
      (set-face-attribute 'variable-pitch nil :family "FiraGo"))
     ((eq system-type 'gnu/linux)
      (set-face-attribute 'default nil :family "Hack" :height 110)
      (set-face-attribute 'fixed-pitch nil :family "Hack")
      (set-face-attribute 'variable-pitch nil :family "FiraGo"))
     (t
      (set-face-attribute 'default nil :family "Hack" :height 110)
      (set-face-attribute 'fixed-pitch nil :family "Hack")
      (set-face-attribute 'variable-pitch nil :family "DejaVu Sans"))))
#+end_src

In case of proper initialization of all face heigths, font scaling is easy as
the the code in [[lst:my-set-default-face-height]] shows.

#+caption[Implement =my-set-default-face-height=]:
#+caption: Implement =my-set-default-face-height=.
#+label: lst:my-set-default-face-height
#+begin_src emacs-lisp
  (defun my-set-default-face-height ()
    "Set the default face height in all current and future frames.

  Scale all other faces with a height that is a real number."
    (interactive)
    (let* ((prompt (format "face heigth (%s): "
                           (face-attribute 'default :height)))
           (choices (mapcar #'number-to-string
                            (number-sequence 50 200 10)))
           (height (string-to-number
                    (completing-read prompt choices nil 'require-match))))
      (message "Setting the height of the default face to %s" height)
      (set-face-attribute 'default nil :height height)))
#+end_src

Allow swapping fhe foreground and background colors of the default face on all
frames.

#+caption[Implement =my-invert-default-face=]:
#+caption: Implement =my-invert-default-face=.
#+label: lst:my-invert-default-face
#+begin_src emacs-lisp
  (defun my-invert-default-face ()
    "Invert the default face."
    (interactive)
    (invert-face 'default))
#+end_src

Enable =rainbow-mode= to colorize color names in buffers for debugging.

#+caption[Enable =rainbow-mode=]:
#+caption: Enable =rainbow-mode=.
#+label: lst:enable-rainbow-mode
#+begin_src emacs-lisp
  (when (fboundp 'rainbow-mode)
    (custom-set-variables
     '(rainbow-x-colors-major-mode-list
       '(c++-mode
         c-mode
         emacs-lisp-mode
         inferior-emacs-lisp-mode
         java-mode
         lisp-interaction-mode
         org-mode
         python-mode)))
    (rainbow-mode +1))
#+end_src

This setup prefers the ~leuven~ and ~leuven-dark~ themes because the
~modus-operandi~ and ~modus-vivendi~ themes feel quirky: for instance those
themes fail to display ~hl-line-mode~ properly with Emacs-27.2 on Darwin.

[[https://emacs.stackexchange.com/questions/17431/how-do-i-change-portions-of-a-custom-theme][How to change custom theme faces]]

#+caption[Hack =leuven-theme=]:
#+caption: Hack =leuven-theme=.
#+label: lst:hack-leuven-theme
#+begin_src emacs-lisp
  (unless noninteractive
    ;; Try to detect `leuven-theme` from MELPA.
    (when (fboundp 'leuven-scale-font)
      (custom-set-variables
       '(leuven-scale-org-agenda-structure 1.0)
       '(leuven-scale-org-document-title 1.0)
       '(leuven-scale-outline-headlines 1.0)
       '(leuven-scale-volatile-highlight 1.0)))

    (defun my-leuven-hook-function ()
      (when (member 'leuven custom-enabled-themes)
        (let ((custom-inhibit--theme-enable nil)
              (ol1 (list :height 1.0 :weight 'bold
                         :foreground "#3C3C3C" :background "#F0F0F0"))
              (ol2 (list :height 1.0 :weight 'bold
                         :foreground "#123555" :background "#E5F4FB")))
          (custom-theme-set-faces
           'leuven
           `(font-latex-sectioning-2-face ((t ,ol1)))
           `(font-latex-sectioning-3-face ((t ,ol2)))
           `(info-title-1 ((t ,ol1)))
           `(markdown-header-face-1 ((t ,ol1)))
           `(markdown-header-face-2 ((t ,ol2)))
           `(org-level-1 ((t ,ol1)))
           `(org-level-2 ((t ,ol2)))
           `(outline-1 ((t ,ol1)))
           `(outline-2 ((t ,ol1)))))
        (enable-theme 'leuven)))

    ;; (load-theme 'leuven 'no-confirm nil)

    (dolist (hook '(Info-mode-hook
                    LaTeX-mode-hook
                    markdown-mode-hook
                    org-mode-hook
                    outline-mode-hook))
      (add-hook hook #'my-leuven-hook-function)))
#+end_src

#+caption[Implement =my-pulse-one-line=]:
#+caption: Implement =my-pulse-one-line=.
#+label: lst:my-pulse-one-line
#+begin_src emacs-lisp
  (unless noninteractive
    ;; https://karthinks.com/software/batteries-included-with-emacs/
    ;; https://www.reddit.com/r/emacs/comments/jwhr6g/batteries_included_with_emacs/
    (defun my-pulse-one-line (&rest _)
      "Pulse the current line."
      (let ((pulse-iterations 16)
            (pulse-delay 0.1))
        (pulse-momentary-highlight-one-line (point))))
    (dolist (command '(scroll-up-command
                       scroll-down-command
                       recenter-top-bottom
                       other-window))
      (advice-add command :after #'my-pulse-one-line)))
#+end_src

* Applications

** Feed reader

#+caption[Enable =elfeed=]:
#+caption: Enable =elfeed=.
#+label: lst:enable-elfeed
#+begin_src emacs-lisp
  (autoload 'elfeed "elfeed" nil t)
  (global-set-key (kbd "C-x w") #'elfeed)

  (with-eval-after-load 'elfeed
    (custom-set-variables
     '(elfeed-feeds
       '(("http://www.howardism.org/index.xml" h-abrams)
         ("https://ambrevar.xyz/atom.xml" p-neirhardt)
         ("https://emacshorrors.com/feed.atom" v-schneidermann)
         ("https://emacsninja.com/emacs.atom" v-schneidermann)
         ("https://feeds.feedburner.com/InterceptedWithJeremyScahill" j-scahill)
         ("https://nullprogram.com/feed/" c-wellons)
         ("https://oremacs.com/atom.xml" o-krehel)
         ("https://planet.emacslife.com/atom.xml" planet-emacs)
         ("https://protesilaos.com/codelog.xml" p-stavrou)
         ("https://sachachua.com/blog/category/emacs/feed" s-chua)
         ("https://sciencescitoyennes.org/feed/" sciences)
         ("https://updates.orgmode.org/feed/updates" org-updates)
         ("https://www.aclu.org/taxonomy/feed-term/2152/feed" aclu)
         ("https://www.bof.nl/rss/" bof)
         ("https://www.democracynow.org/podcast-video.xml" dn)
         ("https://www.laquadrature.net/fr/rss.xml" lqdn)
         ("https://www.lemonde.fr/blog/huet/feed/" sciences)))))
#+end_src

** Multi-media system

#+caption[Enable =emms=]:
#+caption: Enable =emms=.
#+label: lst:enable-emms
#+begin_src emacs-lisp
  (custom-set-variables
   '(emms-mode-line-format "")
   '(emms-player-list '(emms-player-mpd emms-player-mpv))
   `(emms-player-mpd-music-directory ,(expand-file-name "~/Music"))
   '(emms-player-mpd-server-name "localhost")
   '(emms-player-mpd-server-port "6600")
   '(emms-player-mpd-verbose t)
   '(emms-playing-time-display-format " %s ")
   '(emms-playlist-mode-center-when-go t))

  (defun my-emms-print-metadata-find ()
    (require 'find-func)
    (locate-file
     "emms-print-metadata"
     (expand-file-name
      "src"
      (file-name-directory (find-library-name "emms")))
     exec-suffixes #'file-executable-p))

  (with-eval-after-load 'emms
    (require 'emms-info-libtag)
    (let ((emms-print-metadata (my-emms-print-metadata-find)))
      (when emms-print-metadata
        (custom-set-variables
         '(emms-info-functions nil)
         `(emms-info-libtag-program-name ,emms-print-metadata))
        (add-hook 'emms-info-functions #'emms-info-libtag))))

  (with-eval-after-load 'elfeed-show
    (when (require 'emms-setup nil 'noerror)
      (emms-all)))

  (autoload 'emms-streams "emms-streams" nil 'interactive)
  (with-eval-after-load 'emms-streams (emms-all))
#+end_src

* [[info:emacs#Init File][Init File (info)]] footer
:PROPERTIES:
:CUSTOM_ID: sec:user-init-file-footer
:END:

#+caption[Tangle the =user-init-file= footer]:
#+caption: Tangle the =user-init-file= footer.
#+label: lst:tangle-user-init-file-footer
#+begin_src emacs-lisp
  (provide 'init)

  ;; Emacs looks for "Local variables:" after the last "?\n?\f".
  
  ;; Local Variables:
  ;; indent-tabs-mode: nil
  ;; End:
  ;;; init.el ends here
#+end_src

* Local variables linking to [[#sec:latexmk-save-compile-display-loop][Latexmk save-compile-display-loop]]
:PROPERTIES:
:CUSTOM_ID: sec:local-variables
:END:

Only the [[info:org#Top][Org]] source file shows the local variables footer.

# Emacs looks for "Local variables:" after the last "\?n\?f".

# Local Variables:
# compile-command: "latexmk -interaction=nonstopmode -lualatex -pvc -shell-escape README.tex"
# eval: (apply 'my-org-eval-blocks-named '("emacs-lisp-setup"))
# fill-column: 80
# End: