Mercurial > org > meta / babel.org

 #+title: babel
 #+author: Richard Westhaver
 #+description: Core Library of Babel
 #+setupfile: ../clean.theme
 #+property: header-args :exports both :eval no-export
 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.
 
 This library depends on the [[vc:core][core]] being properly installed and the
 =core/emacs= init system loaded in emacs. See [[vc:home][home]] for details.
 
 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:
 :PROPERTIES:
 :ID:       70334979-e1fd-442d-815f-9eeb7d21ef4f
 :END:
 #+name: echo
 #+begin_src emacs-lisp :var input=""
 input
 #+end_src
 * read                                                                   :fs:
 :PROPERTIES:
 :ID:       dade8198-f8ff-4ae9-a52d-becdc1a9c3ce
 :END:
 #+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:
 :PROPERTIES:
 :ID:       a866820f-e67c-49aa-ba7d-697c4f708654
 :END:
 #+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:
 :PROPERTIES:
 :ID:       063109d3-3bb1-45b3-b963-6b306776798c
 :END:
 #+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:
 :PROPERTIES:
 :ID:       e21d6130-804d-4ac7-bccf-8303fd33f509
 :END:
 #+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:
 :PROPERTIES:
 :ID:       e35c9901-73b6-4794-8900-42860378c7dd
 :END:
 #+name: transpose
 #+begin_src emacs-lisp :var table=""
   (apply #'mapcar #'list (list table))
 #+end_src
 * all-to-string                                                       :table:
 :PROPERTIES:
 :ID:       a122b2bd-abd6-4486-97c8-242e6534e5a8
 :END:
 #+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-lines                                                               :fs:
 :PROPERTIES:
 :ID:       70008815-9634-48ca-b672-b8dcf2a44074
 :END:
 #+name: wc-lines
 #+begin_src shell :dir "."
 cat * | wc -l
 #+end_src
 
 #+RESULTS: wc-lines
 : 1574
 
 * wc-words                                                               :fs:
 :PROPERTIES:
 :ID:       be755790-f367-4654-87e5-cd2927bfef45
 :END:
 #+name: wc-words
 #+begin_src shell :dir "."
 cat * | wc -w
 #+end_src
 
 #+RESULTS: wc-words
 : 5944
 
 * buffer-name                                                          :util:
 :PROPERTIES:
 :ID:       7e9f492e-224a-4cf5-b36d-828ccedc630a
 :END:
 #+name: buffer-name
 #+begin_src emacs-lisp
 (buffer-name)
 #+end_src
 
 * lines                                                                  :fs:
 :PROPERTIES:
 :ID:       670e9855-f8d2-43eb-86af-3ef7292f90b9
 :END:
 #+name: lines
 #+begin_src shell :dir "." :results table replace
   input=`tokei -C -o json`
   echo $input | jq -r '.["Total"] | .code, .comments, .blanks'
 #+end_src
 
 #+RESULTS: lines
 | 1584 |
 |    1 |
 |  127 |
 
 * langs                                                                  :fs:
 :PROPERTIES:
 :ID:       ff9682f0-bb64-427f-a87d-e0c655f9fdc9
 :END:
 #+name: langs
 #+begin_src shell :dir "." :results output table replace
   input=`tokei -C -o json`
   echo $input | jq -r '.["Total"].children | keys[]'
 #+end_src
 
 #+RESULTS: langs
 : Org
 
 * sum-str-nums                                                         :util:
 :PROPERTIES:
 :ID:       d3c4ac69-337f-430b-a4db-760504f099ea
 :END:
 #+name: sum-str-nums
 #+begin_src emacs-lisp :var str=lines()
   (let ((tot 0))
     (cl-loop
      with tot = 0
      for i in (split-string str) 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
 
 * trim                                                                 :util:
 #+name: trim
 #+begin_src bash :var str=""
   # remove leading whitespace characters
   str="${str#"${str%%[![:space:]]*}"}"
   # remove trailing whitespace characters
   str="${str%"${str##*[![:space:]]}"}"
   printf '%s' "$str"
 #+end_src
 
 #+RESULTS: trim
 : a b c
 
 * skel-show
 #+name: skel-show
 #+begin_src shell :dir "~/comp/core" :var key=":id" :results replace
   echo $(skel show $key)
 #+end_src
 
 #+RESULTS: skel-show
 : 15bc-b763-ec92-1cf5
 
 #+RESULTS:
 : (core lisp rust emacs c)
 * project-root                                                      :project:
 #+name: project-root
 #+begin_src emacs-lisp :var project=(project-current)
   (project-root project)
 #+end_src
 
 #+RESULTS: project-root
 : ~/comp/org/meta/
 
 * project-name                                                      :project:
 #+name: project
 #+begin_src emacs-lisp :var project="."
   (project-name (project-current nil project))
 #+end_src
 
 #+RESULTS: project
 : meta
 
 * project-vc                                                        :project:
 #+name: project-vc
 #+begin_src emacs-lisp :var project=(project-current)
   (cadr project)
 #+end_src
 
 #+RESULTS: project-vc
 : Hg
 
 * project-list                                                      :project:
 #+name: project-list
 #+begin_src emacs-lisp
   project--list
 #+end_src
 
 #+RESULTS: project-list
 | ~/comp/core/                    |
 | ~/comp/org/meta/                |
 | ~/.emacs.d/elpa/corfu-terminal/ |
 | ~/comp/core                     |
 | ~/comp/scratch/zig-pg/          |
 | ~/comp/scratch/wam/             |
 | ~/comp/scratch/vdeplug4/        |
 | ~/comp/scratch/tmux/            |
 | ~/comp/scratch/scryer-prolog/   |
 | ~/comp/scratch/screamer/        |
 | ~/comp/scratch/rerun/           |
 | ~/comp/scratch/r8k/             |
 | ~/comp/scratch/qemu/            |
 | ~/comp/scratch/octatrack/       |
 | ~/comp/scratch/nu_plugin_quic/  |
 | ~/comp/scratch/mpk/             |
 | ~/comp/scratch/lemmy/           |
 | ~/comp/scratch/io-uring/        |
 | ~/comp/scratch/infodb/          |
 | ~/comp/scratch/hy/              |
 | ~/comp/scratch/hg/              |
 | ~/comp/scratch/hackrf/          |
 | ~/comp/scratch/gengat/          |
 | ~/comp/scratch/fin/             |
 | ~/comp/scratch/egui/            |
 | ~/comp/scratch/egui-video/      |
 | ~/comp/scratch/dev/             |
 | ~/comp/scratch/davfs2/          |
 | ~/comp/scratch/crust-0/         |
 | ~/comp/scratch/cepl.examples/   |
 | ~/comp/scratch/cc-install/      |
 | ~/comp/scratch/blok/            |
 | ~/comp/scratch/archiso/         |
 | ~/comp/scratch/arch-boxes/      |
 | ~/comp/scratch/                 |
 | ~/comp/pod/                     |
 | ~/comp/org/notes/               |
 | ~/comp/org/docs/                |
 | ~/comp/org/blog/                |
 | ~/comp/org/archive/             |
 | ~/comp/org/                     |
 | ~/comp/infra/.stash/src/emacs/  |
 | ~/comp/infra/                   |
 | ~/comp/home/                    |
 | ~/comp/etc/                     |
 | ~/comp/demo/                    |
 | ~/comp/box/                     |
 | ~/.emacs.d/elpa/org-glossary/   |
 | ~/comp/org/plan/                |
 | ~/.emacs.d/elpa/eglot-x/        |
 
 * project-details                                                   :project:
 #+name: project-details
 #+begin_src emacs-lisp :var project="."
   (let* ((project (project-current nil project))
          (name (project-name project))
          (root (project-root project))
          (vc-type (downcase (symbol-name (cadr project))))
          (age (org-sbe hg-log-age ''(dir root)))
          (rev (org-sbe hg-rev ''(dir root)))
          (num (org-sbe hg-id-num ''(dir root)))
          (tags (org-sbe skel-show (key "':tags'") ''(dir root)))
          (id (org-sbe skel-show (key "':id'") ''(dir root)))
          (version (org-sbe skel-show (key "':version'") ''(dir root)))
          (description (org-sbe skel-show (key "':description'") ''(dir root)))
          (vc (format ":%s [[https://vc.compiler.company/%s][vc.compiler.company/%s]] :rev %s"
                      vc-type name name
                      (format "[[https://vc.compiler.company/%s/rev/%s][%s:%s]]" name rev rev num)))
          (langs (mapcar (lambda (x) (downcase (format "%s" x))) (flatten (read (org-sbe langs ''(dir root))))))
          (line-counts (flatten (read (org-sbe lines ''(dir root)))))
          (line-sum (cl-reduce '+ line-counts))
          (lines (format "%s :λ %s :# %s :_ %s" line-sum (pop line-counts) (pop line-counts) (pop line-counts))))
     `(hline
       (name ,name)
       (version ,version)
       (description ,description)
       (skel-id ,id)
       (root ,root)
       (vc ,vc)
       (tags ,tags)
       (updated ,age)
       (langs ,langs)
       (lines ,lines)
       hline))
 #+end_src
 
 #+RESULTS: project-details
 |-------------+---------------------------------------------------|
 | name        | meta                                              |
 | version     | 0.1.0                                             |
 | description | The Compiler Company Core                         |
 | skel-id     | 15bc-b763-ec92-1cf5                               |
 | root        | ~/comp/org/meta/                                  |
 | vc          | :hg [[https://vc.compiler.company/meta][vc.compiler.company/meta]] :rev [[https://vc.compiler.company/meta/rev/06698c6708de][06698c6708de:8+]] |
 | tags        | (core lisp rust emacs c)                          |
 | updated     | 3 days ago                                        |
 | langs       | (org)                                             |
 | lines       | 1768 :λ 1632 :# 3 :_ 133                          |
 |-------------+---------------------------------------------------|
 
 * files                                                                  :fs:
 :PROPERTIES:
 :ID:       e2ff9dcf-8340-48b8-a1a6-e0036cbcc495
 :END:
 #+name: format-files
 #+begin_src python :var tab="" :results table :colnames yes :hlines yes :exports results :eval no-export
 return tab
 #+end_src
 
 #+name: files
 #+begin_src sh :results replace table :dir "." :colnames yes :hlines yes :post format-files-tbl(*this*)
   ls -lh $PWD --time-style=long-iso \
     |awk '{if (NR!=1) print $8, $5, $6"-"$7}' \
     |awk 'BEGIN{print "file size updated"}{print $0}'
 #+end_src
 
 #+RESULTS: files
 | file          | size |          updated |
 |---------------+------+------------------|
 | babel.org     | 24K  | 2024-09-07-19:45 |
 | business.org  | 803  | 2024-08-19-21:19 |
 | glossary.org  | 1.2K | 2024-09-06-15:35 |
 | mindset.org   | 119  | 2024-08-15-21:20 |
 | pitch.org     | 1.6K | 2024-08-11-17:16 |
 | readme.org    | 1.1K | 2024-08-27-21:13 |
 | style.org     | 3.2K | 2024-08-21-16:18 |
 | tech.org      | 3.6K | 2024-08-21-18:16 |
 | ulang.org     | 12K  | 2024-09-06-16:12 |
 | workflows.org | 7.5K | 2024-09-03-16:59 |
 
 * 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-buffer-log                                                          :vc:
 :PROPERTIES:
 :ID:       b2d9f6f0-2ac7-4e45-abbe-b32cc2d0f7aa
 :END:
 #+name: vc-buffer-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 :dir "."
 hg log -l 1 --template '{node|short}'
 #+end_src
 
 #+RESULTS: hg-rev
 : 06698c6708de
 * hg-id-num                                                              :vc:
 :PROPERTIES:
 :ID:       9602faee-5522-445b-a568-be603e20a978
 :END:
 #+name: hg-id-num
 #+begin_src shell :dir "."
 hg id -n
 #+end_src
 
 #+RESULTS: hg-id-num
 : 8+
 
 * hg-log-age                                                             :vc:
 :PROPERTIES:
 :ID:       8492f4fb-51a6-4221-8705-a15eb5a50ed4
 :END:
 #+name: hg-log-age
 #+begin_src shell :dir "."
   hg log -l1 --template "{date|age}"
 #+end_src
 
 #+RESULTS: hg-log-age
 : 3 days ago
 
 * hg-churn                                                               :vc:
 #+name: hg-churn
 #+begin_src shell :dir "~/comp/core" :results output
   hg churn -f "%Y-%m" -s
 #+end_src
 
 #+RESULTS: hg-churn
 #+begin_example
 2023-10  36394 ************************************
 2023-11  12777 ************
 2023-12  61624 *************************************************************
 2024-01   4923 ****
 2024-02   5701 *****
 2024-03  27292 ***************************
 2024-04  23322 ***********************
 2024-05  24141 ***********************
 2024-06  17608 *****************
 2024-07   9757 *********
 2024-08  16177 ****************
 2024-09   2430 **
 #+end_example
 
 * hg-status
 #+name: hg-status
 #+begin_src shell :dir "."
 hg status
 #+end_src
 
 #+RESULTS: hg-status
 | M | babel.org    |
 | M | glossary.org |
 | M | ulang.org    |
 
 * homer
 #+begin_src shell
 homer
 #+end_src
 
 #+RESULTS:
 | :PUSH | /home/ellis/.stash/scripts/wg-gen-keys.sh                   |
 | :PUSH | /home/ellis/.stash/scripts/upgrade.sh                       |
 | :PUSH | /home/ellis/.stash/scripts/sc.sh                            |
 | :PUSH | /home/ellis/.stash/scripts/rec.sh                           |
 | :PUSH | /home/ellis/.stash/scripts/port-scan.sh                     |
 | :PUSH | /home/ellis/.stash/scripts/podman-machine-default-update.sh |
 | :PUSH | /home/ellis/.stash/scripts/pacman-pkgsearch.sh              |
 | :PUSH | /home/ellis/.stash/scripts/nfs-export.sh                    |
 | :PUSH | /home/ellis/.stash/scripts/new-mail.sh                      |
 | :PUSH | /home/ellis/.stash/scripts/genfstab.sh                      |
 | :PUSH | /home/ellis/.stash/scripts/gen-libera-cert.sh               |
 
 * 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))
   (slime-repl-set-package "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
   (unless (slime-connected-p) (slime))
   (slime-eval '(ql:quickload :std))
   (slime-repl-set-package "STD-USER")
 #+end_src
 * test-slime                                                           :lisp:
 :PROPERTIES:
 :ID:       ff559b09-1c18-422c-a0ae-681180f685cf
 :END:
 #+name: std-slime
 #+begin_src emacs-lisp :results silent :eval no-export
   (unless (slime-connected-p) (slime))
   (slime-eval '(ql:quickload :core/tests))
   (slime-repl-set-package "CORE/TESTS")
 #+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:
 :PROPERTIES:
 :ID:       d8a3cc05-a4ec-4820-935d-63f676ee32a3
 :END:
 #+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:
 :PROPERTIES:
 :ID:       bde8705d-0969-493d-91b9-51a93ae09efa
 :END:
 #+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:
 :PROPERTIES:
 :ID:       cec80330-99c3-4dab-9b13-bb0a520ace73
 :END:
 #+NAME: filter-table
 #+HEADER: :var tbl="" col=0 vals=""
 #+BEGIN_SRC elisp :results value  :colnames y
   (let ((lst (split-string vals)))
     (concatenate 'list  (loop for row in tbl
                               if (member (let ((field (nth col row)))
                                            (if (numberp field)
                                                (number-to-string field)
                                              field)) lst)
                               collect row into newtbl
                               ;; else do (princ (format "%s: %s\n" (nth col row) lst))
                               finally return newtbl)))
 #+END_SRC
 * filter-table-re                                                  :table:rx:
 :PROPERTIES:
 :ID:       61e82902-3108-4cee-8e02-3e9d6770f5cb
 :END:
 #+NAME: filter-table-re
 #+HEADER: :var tbl="" col=0 vals=".*"
 #+BEGIN_SRC elisp :results value  :colnames y
   (let ((lst (split-string vals)))
     (concatenate 'list  (loop for row in tbl
                               if (let* ((rawfield (nth col row))
                                         (field (if (numberp rawfield)
                                                    (number-to-string rawfield)
                                                  rawfield)))
                                    (loop for regx in lst
                                          when(string-match-p regx field) return 't
                                          finally return nil))
                               collect row into newtbl
                               ;; else do (princ (format "%s: %s\n" (nth col row) lst))
                               finally return newtbl)))
 #+END_SRC
 * group-table                                                         :table:
 :PROPERTIES:
 :ID:       d1cb8d5d-14bc-4fbe-baf0-ff819d51ec4c
 :END:
 #+NAME: group-table
 #+HEADER: :var tbl="" grp="Name" op="sum" rescols="B"
 #+BEGIN_SRC python :results output verbatim drawer :colnames no
   import pandas as pd
   import numpy as np
   import orgbabelhelper as obh
   import sys
   import re
 
   df = obh.orgtable_to_dataframe(tbl)
   grparr = re.split(r",\s*", grp)
   #print re.split(r",\s*", rescols) + [grp]
   df = df[re.split(r",\s*", rescols) + grparr]
   for elem in grparr:
       assert elem in df.columns, "Error: group column %s not in table columns %s" % (elem, ",".join(df.columns))
 
   if op == "sum":
       res = df.groupby(grparr).sum()
   else:
       error("operation %s not implemented" % op)
       sys.exit(1)
 
   print(obh.dataframe_to_orgtable(res))
 
 #+END_SRC
 * insert-file                                                            :fs:
 :PROPERTIES:
 :ID:       57196c4d-a275-4023-8462-a5847676347c
 :END:
 #+NAME: lobInsertFile
 #+HEADER: :var filename="/tmp/foo"
 #+begin_src elisp :results value raw drawer
   (cl-labels ((wrap-src
   	      (lang)
   	      (list (format "#+BEGIN_SRC %s :eval never :exports source\n" lang)
                       "#+END_SRC\n")))
     (let ((wrappers
   	 (pcase (file-name-extension filename)
   	   ("py" (wrap-src "python"))
   	   (".el" (wrap-src "emacs-lisp"))
   	   (t '("#+BEGIN_EXAMPLE\n" "#+END_EXAMPLE\n")))))
       (with-temp-buffer
         (goto-char (point-min))
         (insert (format-time-string "# inserted at %Y-%m-%d %H:%M:%S\n"))
         (insert (car wrappers))
         (insert-file-contents filename)
         (goto-char (point-max))
         (insert (car (cdr wrappers)))
         (buffer-string))))
 #+end_src