#+title: babel

 #+author: Richard Westhaver

 #+description: Core Library of Babel

 #+setupfile: ../clean.theme

 Welcome to the CC [[https://www.gnu.org/software/emacs/manual/html_node/org/Library-of-Babel.html][Library of Babel]]. This file contains a collection of

 code blocks which may be used by authors throughout our public

 documentation.

 To load the library itself use ~C-c C-v i~ while visiting this file in

 an org-mode buffer or =org-babel-lob-ingest= from elisp.

 * echo                                                                 :util:

 #+name: echo

 #+begin_src emacs-lisp :var input=""

 input

 #+end_src

 * read                                                                   :fs:

 #+name: read

 #+begin_src emacs-lisp :var file="" :var format=""

 (if (string= format "csv")

     (with-temp-buffer

       (org-table-import (expand-file-name file) nil)

       (org-table-to-lisp))

   (with-temp-buffer

     (insert-file-contents (expand-file-name file))

     (buffer-string)))

 #+end_src

 * write                                                                  :fs:

 #+name: write

 #+begin_src emacs-lisp :var data="" :var file="" :var ext='()

 (cl-flet ((echo (r) (if (stringp r) r (format "%S" r))))

   (with-temp-file file

     (case (and (listp data)

                (or ext (intern (file-name-extension file))))

       ('tsv (insert (orgtbl-to-tsv data '(:fmt echo))))

       ('csv (insert (orgtbl-to-csv data '(:fmt echo))))

       (t    (org-babel-insert-result data)))))

 nil

 #+end_src

 * json                                                                 :json:

 #+name: json

 #+begin_src emacs-lisp :var file='() :var url='()

 (require 'json)

 (cond

  (file

   (org-babel-with-temp-filebuffer file

     (goto-char (point-min))

     (json-read)))

  (url

   (require 'w3m)

   (with-temp-buffer

     (w3m-retrieve url)

     (goto-char (point-min))

     (json-read))))

 #+end_src

 * headline                                                              :org:

 #+name: headline

 #+begin_src emacs-lisp :var headline="" :var file='()

 (save-excursion

   (when file (get-file-buffer file))

   (org-open-link-from-string (org-make-link-string headline))

   (save-restriction

     (org-narrow-to-subtree)

     (buffer-string)))

 #+end_src

 * transpose                                                           :table:

 #+name: transpose

 #+begin_src emacs-lisp :var table=""

   (apply #'mapcar #'list (list table))

 #+end_src

 * all-to-string                                                       :table:

 #+name: all-to-string

 #+begin_src emacs-lisp :var tbl='()

 (defun all-to-string (tbl)

   (if (listp tbl)

       (mapcar #'all-to-string tbl)

     (if (stringp tbl)

         tbl

       (format "%s" tbl))))

 (all-to-string tbl)

 #+end_src

 * systemd-list-units                                                     :os:

 :PROPERTIES:

 :ID:       3b23c98d-a286-4988-846d-2dab3d25803d

 :END:

 #+name: systemd-list-units

 #+begin_src sh :results replace

 systemctl list-units --state=running | grep -v systemd | awk '{print $1}' | grep service

 #+end_src

 * wc-dir-lines                                                           :fs:

 :PROPERTIES:

 :ID:       70008815-9634-48ca-b672-b8dcf2a44074

 :END:

 #+name: wc-dir-lines

 #+begin_src shell :var dir="."

 cd $dir && cat * | wc -l

 #+end_src

 * wc-dir-words                                                           :fs:

 :PROPERTIES:

 :ID:       be755790-f367-4654-87e5-cd2927bfef45

 :END:

 #+name: wc-dir-words

 #+begin_src shell :var dir="."

 cd $dir && cat * | wc -w

 #+end_src

 * tokei-dir-lines                                                        :fs:

 :PROPERTIES:

 :ID:       670e9855-f8d2-43eb-86af-3ef7292f90b9

 :END:

 #+name: tokei-dir-lines

 #+begin_src shell :var src="" :results output replace

   cd ~/comp/$src

   input=`tokei -C -o json`

   echo $input | jq -r '.["Total"] | .code, .comments, .blanks'

 #+end_src

 * tokei-dir-langs                                                        :fs:

 :PROPERTIES:

 :ID:       ff9682f0-bb64-427f-a87d-e0c655f9fdc9

 :END:

 #+name: tokei-dir-langs

 #+begin_src shell :var src="org" :results output replace

   cd ~/comp/$src

   input=`tokei -C -o json`

   echo $input | jq -r '.["Total"].children | keys[]'

 #+end_src

 * sum-str-nums                                                         :util:

 :PROPERTIES:

 :ID:       d3c4ac69-337f-430b-a4db-760504f099ea

 :END:

 #+name: sum-str-nums

 #+begin_src emacs-lisp :var s=tokei-dir-lines()

   (let ((tot 0))

     (cl-loop

      with tot = 0

      for i in (split-string s) do

      (setf tot (+ tot (string-to-number i)))

      finally return tot))

 #+end_src

 * org-task-tbl                                                          :org:

 :PROPERTIES:

 :ID:       0ee5b499-6f0b-4e15-8c6e-4876e90c20a9

 :END:

 #+name: org-task-tbl

 #+begin_src emacs-lisp

   (let* ((ast (org-element-parse-buffer)) ;; built up the abstract syntax tree of the org buffer

          item-types ; all occuring item types. It could be that some task has more item types than another.

          tasks ; accumulation list for the tasks

          current-task ; name of the current task (header of level 1)

          task-items) ; items of the current task

     (org-element-map ast 'headline

       (lambda (hl)

         (cl-case (org-element-property :level hl)

           (1 ; We assume here that headers of level 1 are tasks.

            (when current-task ; registering the old task

              (setq tasks (cons (cons current-task (nreverse task-items)) tasks)))

            (setq current-task (org-element-property :raw-value hl) ; preparing the new task

                  task-items nil))

           (2 ; item

            (let ((item-type (org-element-property :raw-value hl)))

              (setq item-types (cons item-type item-types))

              (setq task-items (cons (cons item-type (org-element-property :todo-keyword hl))

                                     task-items)))))))

     (setq tasks (nreverse (cons (cons current-task (nreverse task-items)) tasks)) ;add the last task

           item-types (sort (cl-remove-duplicates (nreverse item-types) :test 'string-equal) ; list of unique item types

                            #'string<)) ;;Sorting the items lexicographical. Other criteria could be applied.

       ;;;;;;;;;;

     ;; generating the output table:

     (apply

      #'list

      (cons "Item" (mapcar #'car tasks)) ; header

      'hline

      ;; rows:

      (mapcar

       ;; mapping the items to the todo states associated to the tasks:

       (lambda (item-type)

         (cons item-type

               (mapcar

                (lambda (task)

                  (let ((todo-status (cdr (assoc-string item-type task))))

                    todo-status))

                tasks)))

       item-types)))

 #+end_src

 * org-headlines-map                                                     :org:

 :PROPERTIES:

 :ID:       05955228-ca76-48bc-b769-f648b4310a9c

 :END:

 #+name: org-headlines-map

 #+begin_src elisp

   (org-element-map (org-element-parse-buffer 'headline)

       'headline

     (lambda(hl)

       (let ((parent (org-element-property :parent hl)))

         (and (eq (org-element-type parent) 'headline)

              (list (org-element-property :title parent) (org-element-property :title hl))))))

 #+end_src

 * make-files-tbl                                                     :org:fs:

 :PROPERTIES:

 :ID:       e2ff9dcf-8340-48b8-a1a6-e0036cbcc495

 :END:

 #+name: ls-files

 #+begin_src sh :results silent :var dir=(expand-file-name "~/comp") name="org"

   ls -lh $dir/$name --time-style=long-iso \

     |awk '{if (NR!=1) print $8, $5, $6"-"$7}' \

     |awk 'BEGIN{print "file size updated"}{print $0}'

 #+end_src

 #+name: make-files-tbl

 #+begin_src python :var tab=ls-files() :results table :colnames yes :hlines yes :exports results :eval no-export

 return tab

 #+end_src

 * env-table                                                              :os:

 :PROPERTIES:

 :ID:       4c824478-0eaa-49b9-905f-2c9a6d4220eb

 :END:

 #+begin_src sh :results table replace

   for i in $(env);

   do

       echo "$i|" | sed '0,/=/s//|/'

   done

 #+end_src

 * get-env                                                                :os:

 :PROPERTIES:

 :ID:       8c1ecc68-ca25-4e72-81d8-415a43e59ae4

 :END:

 #+name: get-env

 #+begin_src elisp :results output :var key="HOME"

 (princ (getenv key))

 #+end_src

 #+RESULTS: get-env

 : /home/ellis

 * org-current-h1-title                                                  :org:

 :PROPERTIES:

 :ID:       ae61e7ed-c9ed-414c-8a5f-12b1702f018e

 :END:

 #+name: org-current-h1-title

 #+begin_src emacs-lisp :results value

   (org-element-property :title (save-excursion (org-up-heading-safe) (org-element-at-point)))

 #+end_src

 #+RESULTS: org-current-h1-title

 : org-current-h1-title

 * get-emacs-version                                                   :emacs:

 :PROPERTIES:

 :ID:       af3d83a1-31bd-41b4-be35-c1f33507fd8d

 :END:

 #+name: get-emacs-version

 #+begin_src elisp :results output

   (princ (concat (format "%s\n" (emacs-version))

 		 (format "Org v%s" (org-version))))

 #+end_src

 * vc-log                                                                 :vc:

 #+name: vc-log

 #+header: :var limit=-1

 #+header: :var buf=(buffer-name (current-buffer))

 #+begin_src emacs-lisp

 ;; Most of this code is copied from vc.el vc-print-log

 (require 'vc)

 (when (vc-find-backend-function

        (vc-backend (buffer-file-name (get-buffer buf))) 'print-log)

   (let ((limit -1)

         (vc-fileset nil)

         (backend nil)

         (files nil))

     (with-current-buffer (get-buffer buf)

       (setq vc-fileset (vc-deduce-fileset t)) ; FIXME: Why t? --Stef

       (setq backend (car vc-fileset))

       (setq files (cadr vc-fileset)))

     (with-temp-buffer

       (let ((status (vc-call-backend

                      backend 'print-log files (current-buffer))))

         (when (and (processp status)   ; Make sure status is a process

                    (= 0 (process-exit-status status))) ; which has not terminated

           (while (not (eq 'exit (process-status status)))

             (sit-for 1 t)))

         (buffer-string)))))

 #+end_src

 * hg-rev                                                                 :vc:

 :PROPERTIES:

 :ID:       8119cf43-f2e7-4829-939c-fc4e8531ae6c

 :END:

 #+name: hg-rev

 #+begin_src sh :var src="org"

 cd ~/comp/$src && hg log -l 1 --template '{node|short}'

 #+end_src

 #+RESULTS: hg-rev

 : 2b6f731f3684

 * hg-id-num                                                              :vc:

 :PROPERTIES:

 :ID:       9602faee-5522-445b-a568-be603e20a978

 :END:

 #+name: hg-id-num

 #+begin_src shell :var src="org"

 cd ~/comp/$src && hg id -n

 #+end_src

 #+RESULTS: hg-id-num

 : 36+

 * hg-log-age                                                             :vc:

 :PROPERTIES:

 :ID:       8492f4fb-51a6-4221-8705-a15eb5a50ed4

 :END:

 #+name: hg-log-age

 #+begin_src shell :var src="."

   cd ~/comp/$src && hg log -l1 --template "{date|age}"

 #+end_src

 #+RESULTS: hg-log-age

 * sh-ob-tangle                                                          :org:

 :PROPERTIES:

 :ID:       7b311df4-83a3-489d-89a0-929928bce051

 :END:

 #+name: sh-ob-tangle

 #+begin_src sh

   emacs -Q --batch --eval "

       (progn

 	(require 'ob-tangle)

 	(dolist (file command-line-args-left)

 	  (with-current-buffer (find-file-noselect file)

 	    (org-babel-tangle))))

     " "$@"

 #+end_src

 * make-dot-tree                                                         :dot:

 :PROPERTIES:

 :ID:       5588f446-2d7a-4261-b829-68effd3778ac

 :END:

 #+name: make-dot-tree

 #+begin_src emacs-lisp :var table=org-headlines-map() :results output

   (mapcar #'(lambda (x)

 		(princ (format "\"%s\" -> \"%s\";\n" (cl-first x) (cl-second x))))

 	  table)

 #+end_src

 * gen-dot-tree                                                          :dot:

 :PROPERTIES:

 :ID:       a51c943d-0f01-4c8f-96ec-db28ae7fef26

 :END:

 #+name: gen-dot-tree

 #+begin_src dot :file /tmp/tree.png :cmdline -Kdot -Tpng :var input=make-dot-tree() :eval no-export

 digraph {

    rankdir=TB;

    splines=true;

    node [shape=box];

    $input

   }

 #+end_src

 * user-slime                                                           :lisp:

 :PROPERTIES:

 :ID:       9ffd1d10-ffad-486e-9d7d-82422342b9ff

 :END:

 #+name: user-slime

 #+begin_src emacs-lisp :results silent :eval no-export

   (unless (slime-connected-p) (slime))

   (slime-eval '(ql:quickload :user))

 #+end_src

 * std-slime                                                            :lisp:

 :PROPERTIES:

 :ID:       334dae41-5c35-48bd-8368-71d79f5e48d8

 :END:

 #+name: std-slime

 #+begin_src emacs-lisp :results silent :eval no-export

   (slime-eval '(ql:quickload :std))

 #+end_src

 * cargo-update-dir                                                     :rust:

 :PROPERTIES:

 :ID:       67dc87bb-a27b-46e4-a02f-58daac514630

 :END:

 #+name: cargo-update-dir

 #+begin_src sh :var dir=()

 # update all crates in dir

 set -eu

 case $0 in

    (/*) dir=${0%/*}/;;

    (*/*) dir=./${0%/*};;

    (*) dir=.;;

 esac

 find "$dir/.." -name Cargo.toml -execdir cargo update \;

 #+end_src

 * rust-target-triple                                                   :rust:

 :PROPERTIES:

 :ID:       02f96ff2-c607-4889-979c-943203b8ad65

 :END:

  #+name: rust-target-triple

  #+begin_src shell

  rustc -vV | sed -n -e 's/^host: //p'

  #+end_src

 * post-align-table                                                    :table:

 #+NAME: post-align-tables

 #+header: :var text="|5|22222|\n|0||\n|12|45|\n|---\n|||\n#+TBLFM:@>$1=vsum(@1..@-1)\n\n|1|22222|\n|0||\n|12|45|\n"

 #+BEGIN_SRC emacs-lisp :results value :exports both

   (with-temp-buffer

     (erase-buffer)

     (cl-assert text nil "PostAlignTables received nil instead of text ")

     (insert text)

     (beginning-of-buffer)

     (org-mode)

     (while

         (search-forward-regexp org-table-any-line-regexp nil t)

       (org-table-align)

       (org-table-recalculate 'iterate)

       (goto-char (org-table-end)))

     (buffer-string))

 #+END_SRC

 * insert-table-from-file                                           :table:fs:

 #+NAME: insert-table-from-file

 #+HEADER: :var tname="table" fname="/tmp/tbl.org" newcaption="" newattr="" newname=""

 #+BEGIN_SRC elisp :results output drawer

   (let* ((klist (cl-remove-if (lambda (x) (equal (cadr x) ""))

     			    `(("ATTR_LATEX" ,newattr) ("CAPTION" ,newcaption) ("NAME" ,newname))))

          (tbl

           (with-temp-buffer

     	  (org-mode)

     	  (insert-file-contents fname)

     	  (goto-char (point-min))

     	  (unless (re-search-forward

     		   (concat "^[ \t]*#\\+\\(tbl\\)?name:[ \t]*"

     			   (regexp-quote tname) "[ \t]*$")

     		   nil t)

     	    (user-error "Can't find table named %s in file" tname fname))

     	  (forward-line 0)

     	  (let ((tstart (match-beginning 0))

     	        tend)

     	    (while (looking-at "^[ \t]*#\\+\\([^:]+\\): *\\(.*\\)")

     	      (add-to-list 'klist `(,(upcase (match-string 1)) ,(match-string 2)))

     	      (delete-region (point) (line-end-position))

     	      (kill-line))

     	    (unless (looking-at org-table-line-regexp)

     	      (looking-at "^.*$")

     	      (user-error "no table at location of %s, Looking-at: '%s'" tname (match-string 0)))

     	    (goto-char (org-table-end))

     	    (while (looking-at-p "^[ \t]*#\\+TBLFM:")

     	      (forward-line 1))

     	    (buffer-substring tstart (point))))))

     (setq klist (nreverse klist)) ;; reverse for giving priority to new user settings

     (dolist (elem '("NAME" "CAPTION" "ATTR_LATEX"))

       (when (assoc elem klist)

         (princ (format "#+%s: %s\n" elem (cadr (assoc elem klist))))))

     (princ tbl))

 #+END_SRC

 * filter-table                                                        :table: