babel

input

(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)))

(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

(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))))

(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)))

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

(defun all-to-string (tbl)
  (if (listp tbl)
      (mapcar #'all-to-string tbl)
    (if (stringp tbl)
        tbl
      (format "%s" tbl))))
(all-to-string tbl)

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

cat * | wc -l

cat * | wc -w

(buffer-name)

input=`tokei -C -o json`
echo $input | jq -r '.["Total"] | .code, .comments, .blanks'

input=`tokei -C -o json`
echo $input | jq -r '.["Total"].children | keys[]'

(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))

(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)))

(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))))))

# remove leading whitespace characters
str="${str#"${str%%[![:space:]]*}"}"
# remove trailing whitespace characters
str="${str%"${str##*[![:space:]]}"}"
printf '%s' "$str"

ls -lh $PWD --time-style=long-iso \
  |awk '{if (NR!=1) print $8, $5, $6"-"$7}' \
  |awk 'BEGIN{print "file size updated"}{print $0}'

skel show $key

(project-root project)

(project-name (project-current nil project))

(cadr project)

project--list

(let* ((project (project-current nil project))
       (name (project-name project))
       (root (project-root project))
       (default-directory root)
       (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'")))
       (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))

(let* ((project (project-current nil project))
       (name (project-name project))
       (root (expand-file-name (project-root project)))
       (project-files-relative-names t)
       (project-vc-include-untracked nil))
  `((file size modified)
    hline
    ,@(mapcar (lambda (x)
                ;; don't rely on project/vc - only include files which exist locally
                (when-let ((attr (file-attributes x)))
                  (list (format "[[https://vc.compiler.company/%s/file/tip/%s][%s]]" name x x)
                        (when-let ((size (file-attribute-size attr)))
                          (file-size-human-readable size))
                        (format-time-string "%Y-%m-%d %H:%M:%S" (file-attribute-modification-time attr)))))
              (project-files project))))

(let ((name (project-name (project-current nil project)))
       (hdr (list '(todo item tags scheduled deadline)
                  'hline))
       (tbl))
  (save-excursion
    (with-current-buffer (find-file-noselect
                          (join-paths company-org-directory 
                                      "plan/tasks/" 
                                      (format "%s.org" name)))
      (org-with-wide-buffer
       (org-map-entries (lambda ()
                          (let ((row))
                            (push (or (org-get-todo-state) "") row)
                            (push (org-get-heading t t t t) row)
                            (push (or (remove name (org-get-tags)) "") row)
                            (push (if-let ((ts (org-get-scheduled-time (point) t)))
                                      (format-time-string (cdr org-timestamp-formats) ts)
                                    "")
                                  row)
                            (push (if-let ((ts (org-get-deadline-time (point) t)))
                                      (format-time-string (cdr org-timestamp-formats) ts)
                                    "")
                                  row)
                            (push (nreverse row) tbl)))
                        "TODO<>\"DONE\"" nil)
       )))
  (append hdr (nreverse tbl))
  )

for i in $(env);
do
    echo "$i|" | sed '0,/=/s//|/'
done

(princ (getenv key))

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

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

;; 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)))))

hg log -l 1 --template '{node|short}'

hg id -n

hg log -l1 --template "{date|age}"

# hg log -l1 --template "{date(date, '%Y-%m-%d %H:%M:%S')}\n"
hg log -l1 --template "{date(date)}\n"

hg churn -f "%Y-%m" -s

hg status

homer

emacs -Q --batch --eval "
    (progn
      (require 'ob-tangle)
      (dolist (file command-line-args-left)
        (with-current-buffer (find-file-noselect file)
          (org-babel-tangle))))
  " "$@"

(mapcar #'(lambda (x)
        (princ (format "\"%s\" -> \"%s\";\n" (cl-first x) (cl-second x))))
        table)

digraph {
   rankdir=TB;
   splines=true;
   node [shape=box];
   $input
  }

(unless (slime-connected-p) (slime))
(slime-eval '(ql:quickload :user))
(slime-repl-set-package "USER")

(unless (slime-connected-p) (slime))
(slime-eval '(ql:quickload :std))
(slime-repl-set-package "STD-USER")

(unless (slime-connected-p) (slime))
(slime-eval '(ql:quickload :core/tests))
(slime-repl-set-package "CORE/TESTS")

# update all crates in dir
set -eu
case $0 in
   (/*) dir=${0%/*}/;;
   (*/*) dir=./${0%/*};;
   (*) dir=.;;
esac

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

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

(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))

(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))

(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)))

(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)))

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))

(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))))