Elisp Snippets

> (concat "hello" " world")
"hello world"

> (concat "hello" " world" " elisp ")
"hello world elisp "

> (apply #'concat '("hello" " world " " elisp "))
"hello world  elisp "

(defun join (sep lst)
   (mapconcat 'identity lst sep))

ELISP> (join "," '("1.232" "300"  "500"))
"1.232,300,500"

ELISP> (join ", " '("1.232" "300"  "500"))
"1.232, 300, 500"

> (split-string  "100,200,300,400" ",")
("100" "200" "300" "400")

> (split-string (getenv "PATH") ":")
("/usr/local/sbin" "/usr/local/bin" "/usr/bin" ...)

> (split-string-and-unquote "/bin/app -x -y -z   \"/home/user/some name with space/etc\" -k cmd ")

("/bin/app" "-x" "-y" "-z" "/home/user/some name with space/etc" "-k" "cmd")

(defun align-to-colon (begin end)
  "Align region to colon (:) signs"
  (interactive "r")

  (align-regexp begin end
                (rx (group (zero-or-more (syntax whitespace))) ":") 1 1 ))

(defun align-to-comma (begin end)
  "Align region to comma signs"
  (interactive "r")
  (align-regexp begin end
                (rx "," (group (zero-or-more (syntax whitespace))) ) 1 1 ))


(defun align-to-equals (begin end)
  "Align region to equal signs"
  (interactive "r")
  (align-regexp begin end
                (rx (group (zero-or-more (syntax whitespace))) "=") 1 1 ))

(defun align-to-hash (begin end)
  "Align region to hash ( => ) signs"
  (interactive "r")
  (align-regexp begin end
                (rx (group (zero-or-more (syntax whitespace))) "=>") 1 1 ))

;; work with this
(defun align-to-comma-before (begin end)
  "Align region to equal signs"
  (interactive "r")
  (align-regexp begin end
                (rx (group (zero-or-more (syntax whitespace))) ",") 1 1 ))

(defun join-multi-lines-to-one ()
  "Join multi lines."
  (interactive)
  (let ((beg (region-beginning))
        (end (region-end))
        strings)
    (goto-char beg)
    (back-to-indentation)
    (setq beg (point))
    (goto-char end)
    (goto-char (- (point) 1))
    (end-of-line)
    (setq end (point))
    (setq strings (buffer-substring-no-properties beg end))
    (setq strings (replace-regexp-in-string "\n\\|^>+ *\\|^[\t　 ]+" " " strings))
    (setq strings (replace-regexp-in-string " +" " " strings))
    (delete-region beg end)
    (insert strings)
(goto-char beg)))

;; Exaluate with M-x eval-print-last-sexp

> (read   "(mapc (lambda (p) (insert p) (insert \"\n\"))
               (buffer-list))
        ")

(mapc (lambda (p) (insert p) (insert "
")) (buffer-list))


> (read "(+ 1 2 3 4)")
(+ 1 2 3 4)

> (eval (read "(+ 1 2 3 4)" ))
10

> (eval '(+ 1 2 3 4))
10

(defun clipboard/set (astring)
  "Copy a string to clipboard"
   (with-temp-buffer
    (insert astring)
    (clipboard-kill-region (point-min) (point-max))))

(defun clipboard/get ()
    "Return the content of clipboard as string"
    (interactive)
    (with-temp-buffer
      (clipboard-yank)
      (buffer-substring-no-properties (point-min) (point-max))))

(defun buffer/copy-file-name ()
  (interactive)
  (clipboard/set (buffer-file-name)))

;; Eval using M-x eval-print-last-sexp
;;
> (buffer/copy-file-name)
nil

> (insert (clipboard/get))
/home/arch/projects/emacs/Emacs_Snippets.org

(defun buffer/copy-path ()
  (interactive)
  (clipboard/set (file-name-directory (buffer-file-name)))
  (message "Copied file path to clipboard"))

;; Eval using M-x eval-print-last-sexp
;;
> (buffer/copy-path)
"Copied file path to clipboard"


> (clipboard/get)
"/home/arch/projects/emacs/"

(defun buffer/copy-content ()
  "Copy buffer content to clibpoard
Usage: M-x buffer/copy-content"
  (interactive)
  (clipboard/set
   (buffer-substring-no-properties
    (point-min)
    (point-max)
    )))

(load-file "~/.emacs.d/tools.el")

(load-file "~/.emacs.d/tools.elc")

(defun load-dir (path)
  "
  Load all elisp files (*.el) of a directory

  Usage: (load-dir <path>)

  Example: (load-dir \"~/.emacs.d/custom\")

  "
  (mapc #'load (directory-files path t "\\.el$")))

(add-to-list 'load-path "~/.emacs.d/custom")

;; package -> ~/.emacs.d/custom/package.el
;;
(require 'package)

(defun scratch ()
  "
   Switches to scratch buffer and creates
   it if it doesn't exist.

   Usage: M-x scratch

   This function is useful to Elisp developers.

   Suggestion:
        Add (defalias 's #'scratch) to the init file.
        You can switch to the scratch buffer with > M-x s
   "

  (interactive)

  (let ((buf (get-buffer-create "*scratch*")))

    (switch-to-buffer buf)
    (lisp-interaction-mode)
    ))

(defalias 's #'scratch)

ELISP> (defun eval-string (str) (eval (read str)))
eval-string

ELISP> (defun eval-xclip () (eval-string (shell-command-to-string "xclip -o")))
eval-xclip

;;
;;  Copy the following line in this comment block
;;
;;      (message "Loading my copypaste file...")

ELISP> (eval-xclip)
"Loading my copypaste file..."
ELISP>

ELISP>
ELISP> (defun sample-function (a b c)
           "Function Docstring"
         (+ a (* 5 b) (* 3 c)))


;; Extract Documentation
;;
ELISP> (documentation 'sample-function)
"Function Docstring"

;; Extract Code
;;
ELISP> (symbol-function 'sample-function)
(lambda
  (a b c)
  "Function Docstring"
  (+ a
     (* 5 b)
     (* 3 c)))

;; Extract Arguments
ELISP> (help-function-arglist 'sample-function)
(a b c)

(fun2org 'sample-function)
    "** sample-function (a b c)\nFunction Docstring\n\n#+BEGIN_SRC emacs-lisp\n(lambda (a b c) \"Function Docstring\" (+ a (* 5 b) (* 3 c)))\n#+END_SRC\n"
    ELISP>
    ELISP> (defun fun2org (function-symbol)
      (let ((args (help-function-arglist function-symbol))
            (doc  (documentation function-symbol))
            (code (symbol-function function-symbol)))
        (print (format "** %s %s
    %s

    #+BEGIN_SRC emacs-lisp
    %S

    " function-symbol args doc code)))) ;; End of fun2org

ELISP> (fun2org 'sample-function)

"** sample-function (a b c)
Function Docstring

 (lambda (a b c) \"Function Docstring\" (+ a (* 5 b) (* 3 c)))
"

(describe-function 'find-file-noselect)

(save-buffer)

(kill-buffer <buffer-object or buffer-name>)

(kill-buffer "Elisp_Snippets.org")

(mapc #'kill-buffer (buffer-list))

(defun buffer-content (&optional buffer-or-name)
    (with-current-buffer (if buffer-or-name buffer-or-name (current-buffer))
      (buffer-substring-no-properties (point-min) (point-max)  )))

(defun get-selection ()
  "Get the text selected in current buffer as string"
  (interactive)
  (buffer-substring-no-properties (region-beginning) (region-end)))

(defun python/scratch ()
  (interactive)
    (let (
          ;; Creates a new buffer object.
         (buf (get-buffer-create "*python-scratch*"))
         )
      ;; Executes functions that would change the current buffer at
      ;; buffer buf
     (with-current-buffer buf
       ;;; Set the new buffer to scratch mode
       (python-mode)
       ;;; Pop to scratch buffer
       (pop-to-buffer buf)
       )))

(defun sh/scratch ()
  (interactive)
    (let (
          ;; Creates a new buffer object.
         (buf (get-buffer-create "*sh-scratch*"))
         )
      ;; Executes functions that would change the current buffer at
      ;; buffer buf
     (with-current-buffer buf
       ;;; Set the new buffer to scratch mode
       (sh-mode)
       ;;; Pop to scratch buffer
       (pop-to-buffer buf)
       )))

(buffer-local-variables) ;; Evalute with M-x eval-print-last-sexp

((cursor-type . bar)
(buffer-display-time 22711 20278 987330 737000)
(buffer-display-count . 4)
(buffer-invisibility-spec
(org-babel-hide-hash . t)
(org-babel-hide-hash . t)
(org-babel-hide-hash . t)
(org-babel-hide-hash . t)
(org-babel-hide-result . t)
(org-hide-block . t)
(org-cwidth) (org-link) (outline . t) t)
(buffer-file-truename . "~/Documents/projects/emacs/Elisp_Snippets.org") (point-before-scroll)

(buffer-auto-save-file-format . t)
(buffer-file-format) (buffer-file-coding-system . utf-8-unix)
(enable-multibyte-characters . t)
(mark-active)
(overwrite-mode) ...)

(buffer-local-variables <buffer-name>)

(buffer-local-value VARIABLE BUFFER)

>  (buffer-local-value 'major-mode (current-buffer))
org-mode

(append-to-file <point-min> <point-max> <file-name>)

(append-to-file (point-min) (point-max) "/tmp/afile.txt")

(with-current-buffer "my-buffer-name"
  (append-to-file (point-min) (point-max) "/tmp/afile.txt"))

;; Delete file if exists in order to overwrite it.
(if (file-exists-p filename)
    (delete-file file))

;; Append buffer content to file.
(append-to-file (point-min) (point-max) filename))

(revert-buffer t t t)

(term "htop") ;; C-x C-e or M-x eval-last-sexp

(defun run-terminal ()
  "Launch application in a terminal emulator."
  (interactive)
  (start-process
   "termx"
   nil
   ;; Change this for your terminal.
   "xfce4-terminal" "-e" (read-shell-command "Shell: ")))

(defun shell-command-in-terminal (command)
  (start-process
   "termx"
   nil
   ;; Change this for your terminal.
   "xfce4-terminal" "-e" command))

(shell-command-in-terminal "htop")

(shell-command-in-terminal "nmtui")

(defun htop ()
  "Launch htop task manager."
  (interactive)
  (shell-command-in-terminal "htop"))

(defun shell-launch ()
  "Launch a process without creating a buffer. It is useful to launch apps from Emacs."
  (interactive)
  (let* ((cmd-raw  (read-shell-command "Launch command: "))
         (cmd-args (split-string-and-unquote cmd-raw))
         (cmd      (car cmd-args))       ;; program that will run
         (args     (cdr cmd-args)))     ;; command arguments
    (apply #'start-process `(,cmd
                             nil
                             ,cmd ,@args
                             ))))

(global-set-key (kbd "s-8") #'shell-launch)

(defun shell/buffer-repl ()
  "Create "
  (interactive)

  (delete-other-windows)

  ;; Split window vertically
  (split-window-right)

  ;;; Run shell (bash on Linux)
  (shell)

  ;;; Creates a scratch-shell buffer on other half of window
  (let ((buf (get-buffer-create "*shell-buffer*")))
    (with-current-buffer buf
      (sh-mode)
      (pop-to-buffer buf))))

(defun shell/buffer-repl-frame ()
  (interactive)
  (with-selected-frame (make-frame)
    (shell/buffer-repl)))

(defun shell/send-region ()
  "Send selected text to M-x shell repl."
  (interactive)
  (comint-send-region (get-buffer-process "*shell*" )
                      (region-beginning) (region-end))
  (comint-send-string (get-buffer-process "*shell*" ) "\n"))

(defun shell/insert-region ()
  "Insert selected text into M-x shell repl and run it."
  (interactive)
  (let ((text (buffer-substring-no-properties (region-beginning)
                                              (region-end)
                                              )))
  (with-current-buffer "*shell*"
    (insert text)
    (comint-send-input)
    )))


(defun shell/send-line ()
  "Send current line to M-x shell repl."
  (interactive)
  (comint-send-region (get-buffer-process "*shell*")
                      (line-beginning-position)
                      (line-end-position)
                      )
  (comint-send-string (get-buffer-process "*shell*" ) "\n"))


(defun shell/insert-line ()
  "Insert current line to M-x shell repl."
  (interactive)
  (let ((line (buffer-substring-no-properties
               (line-beginning-position)
               (line-end-position)
               )))
  (with-current-buffer "*shell*"
    (insert line)
    (comint-send-input)
    )))


(defun shell/execute-line ()
  "Execute current line as shell command."
  (interactive)
  (shell-command
   (buffer-substring (line-beginning-position)
                     (line-end-position))))

(defun shell/execute-region ()
  "Execute current region as shell command."
  (interactive)
  (shell-command
   (buffer-substring (region-beginning)
                     (region-end))))

(defun shell/insert-buffer ()
  "Insert all buffer content into M-x shell repl and run it."
  (interactive)
  (let ((text (buffer-substring-no-properties (point-min)
                                              (point-max)
                                              )))
  (with-current-buffer "*shell*"
    (insert text)
    (comint-send-input)
    )))

(setq compile2-command-history "")

(defun compile2 ()
  "Enhanced compilation command.
- %f - is expanded to current buffer file name. 
- %d - is expanded to current buffer current directory.
- %n - is expanded to current buffer base name.

Example: if the current buffer is associated to the file. 
 - /home/arch/scripts/gui1.scala 

If the user enter the command: 

 $ scalac %f -d app-%n.jar && scala app-%n.jar

It will run M-x compile with: 

 $ scalac gui1.scala -d app-gui1.jar && scala scala app-gui1.jar"
  (interactive)
  (let* ((file (buffer-file-name))
         (cmd  (read-shell-command "cmd> " compile2-command-history))
         (cmd1 (replace-regexp-in-string "%f" (file-name-nondirectory file) cmd))
         (cmd2 (replace-regexp-in-string "%n" (file-name-base file) cmd1))
         (cmd3 (replace-regexp-in-string "%d" (file-name-directory file) cmd2)))
    (setq compile2-command-history cmd)
    (save-buffer)
    (compile cmd3)))

(defun cpp/compile-run-buffer ()
  "Compile and run current c++ buffer (single-file C++ code).
Usage: By running M-x cpp/compile-buffer-run at current buffer (file code1.cpp)
will run $ g++ code1.cpp -o code1.bin && ./code1.bin"
  (interactive)
  (let* ((file-name  (file-name-nondirectory (buffer-file-name)))
        ;; Change file name extension to .bin
         (output     (concat (file-name-base file-name) ".bin")))
    (save-buffer)
    (compile (format "g++ %s -o %s && ./%s"
                     file-name
                     output
                     output
                     ))))

(defun cpp/compile-run-dired ()
  "Compile single c++ file at point in dired mode.
Usage: Position the cursor at the file to be compiled and
run M-x cpp/compile-dired."
  (interactive)
  (let* ((file-name  (file-name-nondirectory (dired-file-name-at-point)))
        ;; Change file name extension to .bin
         (output     (concat (file-name-base file-name) ".bin")))
    (save-buffer)
    (compile (format "g++ %s -o %s && ./%s"
                     file-name
                     output
                     output
                     ))))

> (file-exists-p "/var/log/pacman.log") ;; M-x eval-print-last-sexp
t

> (file-exists-p "/var/log/pcaman.log.err")
nil
 ;;
> (file-exists-p "/var/log")
t
 ;;
> (file-exists-p "/var/log-dont-exists")
nil

ELISP> (expand-file-name "~")
"/home/arch"

ELISP> (expand-file-name "~/.emacs.d/init.el")
"/home/arch/.emacs.d/init.el"

ELISP> (expand-file-name ".")
"/home/arch/projects/emacs"

(defun read-file (filename)
  (with-temp-buffer
    (insert-file-contents filename)
    (buffer-substring-no-properties (point-min) (point-max))))

ELISP> (read-file "/etc/host.conf")
"#\n# /etc/host.conf\n#\n\norder hosts,bind\nmulti on\n\n# End of file\n"

ELISP> (princ (read-file "/etc/host.conf"))
#
# /etc/host.conf
#

order hosts,bind
multi on

# End of file

> (setq b1 (find-file-noselect "~/.bashrc"))
#<buffer .bashrc>

> b1
#<buffer .bashrc>

(defun open-as-root (filename)
  (interactive)
  (find-file (concat "/sudo:root@localhost:"  filename)))


;; Example:
;; ELISP> (open-as-root "/etc/host.conf")
;;


;;
;; Open an already opened buffer as root
;;
;; M-x open-buffer-as-root
;;
(defun open-buffer-as-root ()
 (interactive)
 (let
     (
      ;; Get the current buffer file name
      (filename (buffer-file-name (current-buffer)))
      ;; Get the current file name
      (bufname  (buffer-name (current-buffer)))
     )
   (progn
  (kill-buffer bufname)         ;; Kill current buffer
  (open-as-root filename))))    ;; Open File as root

ELISP> (buffer-file-name)
"/home/archbox/.emacs.d/init.el"
ELISP>

ELISP> (file-name-nondirectory "/home/archbox/.emacs.d/init.el")
"init.el"
ELISP>

ELISP> (file-name-base "/home/archbox/.emacs.d/init.el")
"init"
ELISP>

ELISP> (file-name-directory "/home/archbox/.emacs.d/init.el")
"/home/archbox/.emacs.d/"
ELISP>

ELISP> (expand-file-name ".")
"/home/archbox/.emacs.d"

ELISP> (expand-file-name "./init.el")
"/home/archbox/.emacs.d/init.el"
ELISP>

ELISP> (expand-file-name "~")
"/home/archbox"

ELISP> (expand-file-name "~/.bashrc")
"/home/archbox/.bashrc"
ELISP>

ELISP>
(let ((file  "/home/archbox/.emacs.d/init.el"))
  (concat (file-name-directory file)
          (file-name-base file)
          ".py"
          ))

"/home/archbox/.emacs.d/init.py"
ELISP>

(defun file-replace-extension (ext file)
    (concat (file-name-directory file)
            (file-name-base file)
            ext
            ))

ELISP> (file-replace-extension ".py" "/home/archbox/.emacs.d/init.el")
"/home/archbox/.emacs.d/init.py"
ELISP>

ELISP> (directory-files "/var/log")

("." ".." "Xorg.0.log" "Xorg.0.log.old" ... )

ELISP> (mapc #'(lambda (p) (princ (concat "\n" p)))
               (directory-files "/var/log") )

.
..
Xorg.0.log
Xorg.0.log.old
btmp
faillog
httpd
journal
lastlog
old
pacman.log
samba
speech-dispatcher
wtmp

ELISP> (directory-files "/var/log" t)
("/var/log/." "/var/log/.." "/var/log/Xorg.0.log" "/var/log/Xorg.0.log.old" ... )

ELISP> (mapc #'(lambda (p) (princ (concat "\n" p)))
               (directory-files "/var/log" t ))

/var/log/.
/var/log/..
/var/log/Xorg.0.log
/var/log/Xorg.0.log.old
/var/log/btmp
...

;; Files ending with *.conf

ELISP> (directory-files "/etc/" nil "\\.conf")
("asound.conf" "dhcpcd.conf" "fuse.conf" "gai.conf" ...)

ELISP> (directory-files "/etc/" t "\\.conf")
("/etc/asound.conf" "/etc/dhcpcd.conf" "/etc/fuse.conf"  ...)

ELISP> (directory-files "/etc/" t "\\.cfg")
("/etc/rc_maps.cfg" "/etc/vdpau_wrapper.cfg")

ELISP> (directory-files "/etc/" nil "\\.cfg")
("rc_maps.cfg" "vdpau_wrapper.cfg")

(defun dired-copy-path ()
  "In dired, copy file path to kill-buffer.  
At 2nd time it copy current directory to kill-buffer."
  (interactive)
  (let (path)
    (setq path (dired-file-name-at-point))
    (if (string= path (current-kill 0 1)) (setq path (dired-current-directory)))
    (message path)
    (kill-new path)))

(defun dired-paste-file-from-clipboard ()
  "Paste a file from clpboard to current directory."
  (interactive)
  (flet ((clipboard-get ()
                        (with-temp-buffer
                           (clipboard-yank)
                           (buffer-substring-no-properties
                            (point-min)
                            (point-max)))))
    (copy-file (clipboard-get) ".")
    (revert-buffer)))

(defun dired-touch ()
  "Creates empty file at current directory."
  (interactive)
  (append-to-file "" nil (read-string "New file: "))
  (if (equal major-mode 'dired-mode)
      (revert-buffer)))

(defun dired-open-files (files)
  "Open all marked files in dired mode with m.
Usage:
1. Mark the files with m
2. M-x dired-open-files"
  (interactive
   (list (dired-get-marked-files)) )
  (mapc #'find-file files))

(setq lexical-binding t)

(defun compose (fn1 fn2)
  (let ((lexical-binding t))
    (lambda (x)
       (funcall fn2 (funcall fn1 x)))))


(defun dired-close-files (files)
  (interactive  (list (dired-get-marked-files)) )
  (mapc (compose #'get-file-buffer #'kill-buffer) files))

(defun xdg-open (filename)
    "Open a file FILENAME with default system application.
  This function is operating system independent."
    (cl-case system-type

      ;;; Linux
      (gnu/linux      (let ((process-connection-type  nil))
                        (start-process
                            "proc"
                            nil
                            ;; Command
                            "xdg-open" (expand-file-name filename))))

      ;;; Free BSD OS
      (gnu/kfreebsd    (let ((process-connection-type  nil))
                        (start-process
                            "proc"
                            nil
                            ;; Command
                            "xdg-open" (expand-file-name filename))))

      ;; Mac OSX - (Not tested )
      (darwing        (start-process
                       "proc"
                       nil
                       ;; Command
                       "open" (concat  (expand-file-name filename))))

      ;; Windows 7, 8, 10 - Kernel NT
      (windows-nt   (start-process
                     "proc"
                     nil
                     ;; Command
                     "cmd"  "/C"  "start" "" (expand-file-name filename)
                      ))))

(defun dired-xdg ()
  "Open file at point with systems' default app.
Usage: In the dired mode select a file and type M-x dired-xdg
to execute the file with the system default app.
    "
    (interactive)
    (with-current-buffer
        (xdg-open (dired-get-filename))))

(defun dired-close-all ()
  "Close all dired buffers."
  (interactive)
  (mapc (lambda (buf)
          (if (equal (buffer-local-value 'major-mode buf)
                     'dired-mode)
          (kill-buffer buf)))

        (buffer-list)))

(defvar dired-bookmarks-path-list
  '("~"
    "~/Desktop"
    "~/Downloads"
    "~/Documents"
    "~/Documents/projects"
    "~/Documents/wiki"
    "/tmp"
    ;"/mnt/transfer"
    "/var/log"
    "/etc"
    "/etc/init.d"
    "~/.config"
    "~/.local"
    "~/.local/share"
    "~/.emacs.d"
    ))

(defun dired-bookmarks ()
  "Open a directory by selecting it in Helm menu."
  (interactive)
  (helm
   :prompt "Bookmarks: "
   :sources  `((
                (name       . "Bookmark: ")
                (candidates . dired-bookmarks-path-list)
                (action     . dired)
                ))))

  (defun dired/filter-extension ()
    "Filter dired buffer by file extensions.
  Usage:
1. M-x dired/filter-extension
2. Enter the file extensions separated by space like: exe dll

It will only show files ending with extensions *.exe and *.dll.
To show all files of dired buffer again type 'g'."
    (interactive)
    (dired-mark-files-regexp
     (mapconcat 'identity
                (mapcar (lambda (ext) (format "\\.%s$" ext))
                        (split-string (read-string "Extension:  ")))
                "\\\|"
                ))
    (dired-toggle-marks)
    (dired-do-kill-lines))

;; Filter files by extension
(define-key dired-mode-map "'" #'dired/filter-extension)

(defun dired/filter ()
  "Show only files which name matches a regex."
  (interactive)
  (dired-mark-files-regexp (read-regexp "Regex: "))
  (dired-toggle-marks)
  (dired-do-kill-lines))

(defun dired-exec-explorer ()
  "In dired, execute Explorer"
  (interactive)
  (let (path)
    (setq path (dired-file-name-at-point))
    (setq path (replace-regexp-in-string "~" "c:/home" path))
    (setq path (replace-regexp-in-string "/" "\\\\" path))
    (message path)
    ;(kill-new path)
    (start-process "explorer" nil "explorer" (concat "/select," path))))

ELISP> (format-time-string "%Y-%m-%d")
"2017-07-15"

ELISP> (format-time-string "%Y%m%d")
"20170715"
ELISP>

ELISP> (format-time-string "%s")
"1500103484"
ELISP>

ELISP> (current-time)
(22889 50074 486018 948000)

ELISP> (current-time-string)
"Sat Jul 15 04:26:27 2017"
ELISP>

ELISP> (float-time)
1500103652.678849
ELISP>

ELISP> (current-time-zone)
(-10800 "-03")

ELISP>

ELISP> user-init-file
"/home/arch/.emacs.d/init.el"

ELISP> (expand-file-name user-init-file)
"/home/arch/.emacs.d/init.el"

ELISP> user-emacs-directory
"~/.emacs.d/"

ELISP> (expand-file-name user-emacs-directory)
"/home/arch/.emacs.d/"

(defun test-window-system ()
  (interactive)

  (if window-system
       (message  "Running in Window System / GUI")
       (message "Running in terminal ")
       ))

;; In GUI
;;-----------------------------
> (test-window-system)  ;; M-x eval-print-last-sexp
"Running in Window System / GUI"

;; In Terminal
;;------------------------------
> (test-window-system)  ;; M-x eval-print-last-sexp
"Running in terminal "

> (browse-url "http://www.yandex.com")

(defun open-yandex ()
  "Open the web site http://www.yandex.com."
  (interactive)
  (browse-url "http://www.yandex.com"))

(let ((browse-url-browser-function 'browse-url-firefox))
  (browse-url "http://www.yandex.com"))

;; Or

;; Set browser permanently
(setq browse-url-browser-function 'browse-url-firefox)

(let ((browse-url-browser-function 'browse-url-chromium))
  (browse-url "http://www.yandex.com"))

;;; Or

;; Set browser permanently
(setq browse-url-browser-function 'browse-url-chromium)

(let ((browse-url-browser-function 'eww-browse-url))
  (browse-url "http://www.yandex.com")

;;; Or

;; Set browser permanently
(setq browse-url-browser-function 'eww-browse-url)

(eww-browse-url "http://m.reddit.com/r/emacs")

(eww-open-file "/some/html/file.html")

(url-copy-file "http://www.httpbin.org/get" "/tmp/output")
(find-file "/tmp/output")

(with-current-buffer  (url-retrieve-synchronously "http://www.httpbin.org/get")
   (buffer-substring-no-properties (point-min) (point-max)))

(defun download-url-to-file ()
  "Download a file from a URL in the clibpoard.
This command asks the user for the url suggesting the url
stored in the clipboard and then asks the user for the file name
to be downloaded suggesting the file name extracted from the url.
"
  (interactive)
  (let*
      ;; Get the URL suggestion from clibpoard
      ((text (with-temp-buffer
                  (clipboard-yank)
                  (buffer-substring-no-properties (point-min)
                                                  (point-max))))
       ;; Ask the user to confirm the url
       (url (read-string "Url: " text)))

    (url-copy-file
     url
     ;; Get file name.
     (read-file-name "File name: "
                     (car  (last (split-string url "/")))))

    (when (equal major-mode 'dired-mode)
      (revert-buffer))))

(defun download-code-view ()
    "Download a source code from url and displays it on a buffer."
    (interactive)
    (let* (
           ;; Get url from clipboard
           (clipboard (with-temp-buffer
                        (clipboard-yank)
                        (buffer-substring-no-properties (point-min)
                                                        (point-max))))
           ;; Read url and suggesting clipboard
           (url      (read-string "Url: " clipboard))
           (buf      (url-retrieve-synchronously url))
           ;; Tries to extract the file name from url
           (filename (car  (last (split-string url "/"))))
           (bufname  (concat "*" filename "*"))
           )
      (switch-to-buffer buf)
      ;; Remove http header
      (goto-char (point-min))
      (re-search-forward "^$")
      (delete-region (point) (point-min))
      (kill-whole-line)
      ;; Remove \r characters or ^M
      (replace-string (char-to-string 13) "")
      ;; Rename buffer to a better name
      (with-current-buffer buf
        (rename-buffer bufname))))

(defun url-http-post (url args)
  "Send ARGS to URL as a POST request."
  (let (
        (response-string nil)
        (url-request-method "POST")
        (url-request-extra-headers
         '(("Content-Type" . "application/x-www-form-urlencoded")))
        (url-request-data
         (mapconcat (lambda (arg)
                      (concat (url-hexify-string (car arg))
                              "="
                              (url-hexify-string (cdr arg))))
                    args
                    "&")))
    (switch-to-buffer
     (url-retrieve-synchronously url))
    (goto-char (point-min))
    (re-search-forward "\n\n")
    (setq response-string
          (buffer-substring-no-properties (point) (point-max)))
    (kill-buffer (current-buffer))
    response-string))

(defun url-http-get (url args)
  "Send ARGS to URL as a GET request."
  (let (
        (response-string nil)
        (url-request-method "GET")
        (url-request-data
         (mapconcat (lambda (arg)
                      (concat (url-hexify-string (car arg))
                              "="
                              (url-hexify-string (cdr arg))))
                    args
                    "&")))
    (switch-to-buffer
     (url-retrieve-synchronously
      (concat url "?" url-request-data)))
    (goto-char (point-min))
    (re-search-forward "\n\n")
    (setq response-string
          (buffer-substring-no-properties
           (point) (point-max)))
    (kill-buffer (current-buffer))
    response-string))


ELISP> (princ (url-http-get "http://httpbin.org/get" nil))
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip",
    "Content-Length": "0",
    "Extension": "Security/Digest Security/SSL",
    "Host": "httpbin.org",
    "Mime-Version": "1.0",
    "User-Agent": "URL/Emacs"
  },
  "origin": "167.103.159.147",
  "url": "http://httpbin.org/get"
}


ELISP> (princ (url-http-post "http://httpbin.org/post" '(("use" . "dummy")  ("pass" . "something else") ("code" . "pxyz0011213"))))
{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "code": "pxyz0011213",
    "pass": "something else",
    "use": "dummy"
  },
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip",
    "Content-Length": "48",
    "Content-Type": "application/x-www-form-urlencoded",
    "Extension": "Security/Digest Security/SSL",
    "Host": "httpbin.org",
    "Mime-Version": "1.0",
    "User-Agent": "URL/Emacs"
  },
  "json": null,
  "origin": "167.103.159.147",
  "url": "http://httpbin.org/post"
}

> (package-installed-p 'helm-core)
t

(defun package-install-url ()
  "Install a single-file package *.el file from Url."
  (interactive)
  (let* (
         ;; Suggest the URL stored in the clipboard
         (clipboard (with-temp-buffer
                      (clipboard-yank)
                      (buffer-substring-no-properties (point-min) (point-max))))
         ;; Ask the user to confirm the url
         (url (read-string "Url: " clipboard))
         )

     (with-current-buffer (url-retrieve-synchronously url)
       (goto-char (point-min))
       (re-search-forward "^$")
       (delete-region (point) (point-min))
       (kill-whole-line)
      (package-install-from-buffer))))

(defun buffer/with-file-in-directory-p (directory buf)
  "Check if a buffer has file associated and is is in DIRECTORY.
Parameters:
- directory  string         - root directory
- buf        buffer object  - buffer object"
  (and (buffer-file-name buf) ;; check if buffer has a file associated
       (string-prefix-p (expand-file-name directory)
                        (expand-file-name (buffer-file-name buf)
                                            ))))


(defun buffer/switch-in-directory ()
  "Switch between buffers in same directory."
  (interactive)
  (helm
   :prompt "Buffer switch: "
   :sources  `((
                (name       . "Dir: ")
                (candidates . ,(mapcar
                                (lambda (b) (cons (buffer-name b) b))
                                ;; filter buffers not in this directory (code bellow)
                                (remove-if-not  (lambda (b)
                                                  (buffer/with-file-in-directory-p
                                                   (or (file-name-directory (buffer-file-name))
                                                       default-directory
                                                       )
                                                   b
                                                   ))
                                                (buffer-list)
                                                )))
                (action     . switch-to-buffer)
                ))))

(require 'helm)

(defun helm-recent-files ()
  (interactive)
  (helm
   :prompt "File: "
   :sources  `((
                (name       . "File: ")
                (candidates . ,recentf-list)
                (action     . find-file)
                ))))

(require 'helm)

(defun unique (xs)
  "Remove repeated elements from list xs
Example:
> (unique '(x y a b 21 21 10 21 x y a ))
(x y a b 21 10)."
  (let ((result nil))
    (dolist (x xs)
      (if (not (member x result))
          (push x result)))
    (reverse result)))


(defun helm-recent-dirs ()
  (interactive)
  (helm
   :prompt "Dir: "
   :sources  `((
                (name       . "Dir: ")
                (candidates . (lambda ()
                                (unique
                                 (map #'file-name-directory recentf-list))))
                (action     . dired)))))

(defun get-executables ()
  "Returns a list of all files available in the directories of the $PATH variable."
  (apply #'append
   (mapcar  (lambda (p) (directory-files p t))
            (remove-if-not #'file-exists-p
                        (split-string (getenv "PATH") ":")))))


(defun run-async  (&optional command)
  "Run a shell command in asynchronous mode.
It doesn't block Emacs while the command is running.
Usage:  (run-async \"python -m http.server\")
M-x run-async  -> User enters a command."
  (interactive)
  (apply #'start-process
         `(
           "proc-any"          ;; We don't care about the application name
           nil                 ;; Don't name the buffer
           ,@(split-string-and-unquote
              (if  command
                   command
                   (read-string "Command: "  )
                  )))))


(defun run-async-lst (&rest commands)
  "Run a shell command in asynchronus mode, not blocking Emacs.
Usage:    > (run-async-lst <program> <argument 1> <agurment2> ...)
Example:  > (run-async \"thunar\" \"/usr/share/applications\")"
  (apply #'start-process
         `(
           "dontcare"          ;; We don't care about the application name
           nil                 ;; Don't name the buffer
           ,@commands
           )))


(defun helm-launcher ()
  "Launches apps available in $PATH without blocking Emacs.
Usage M-x heml-launcher"
  (interactive)
  (let ((data  (mapcar (lambda (p)
                         (cons (file-name-nondirectory p)
                               p
                               ))
                       (get-executables)
                       )))
   (helm
   :prompt "Shell: "
   :sources  `((
                (name       . "Shell: ")
                (candidates . ,data)
                (action     . run-async)
                )))))

(defun switch-file ()
  "Switch between buffers that are associated with files.
Usage: M-x switch file."
  (interactive)
  (let ((data
         (mapcar (lambda (b)
                   (cons (buffer-file-name b) b ))
                 (remove-if-not #'buffer-file-name (buffer-list)))))
    (helm
     :prompt "Buffer: "
     :sources  `((
                  (name       . "File Buffers")
                  (candidates . ,data)
                  (action     . switch-to-buffer)
                  )))))

(defun helm-switch-mode ()
  "Switch between all major programming modes available in Emacs.
Usage: M-x helm-switch-mode."
  (interactive)
  (cl-flet ((unique (xs)
                    (let
                        ((result nil))
                      (dolist (x xs)
                        (if (not (member x result))
                            (push x result)))
                      (reverse result))))
    (helm
     :prompt "Mode: "
     :sources  `((
                  (name       . "Emacs Major Modes")
                  (candidates . ,(unique (mapcar #'symbol-name
                                                 (remove-if-not #'symbolp
                                                   (mapcar #'cdr auto-mode-alist)))))
                  (action     . ,(lambda (m) (funcall (intern-soft m)))))))))

(setq helm-url-default-url-list
      '(
        ("google" . "http://www.google.ca")
        ("yandex"  . "http://www.yandex.com")
        ("reddit" . "http://www.reddit.com")
        ("/r/haskell". "http://www.reddit.com/r/haskell")
        ("/r/emacs" . "http://www.reddit.com/r/emacs")
        ("/r/csharp" . "http://www.reddit.com/r/csharp")
        ))

(defun helm-web ()
  (interactive)
  (helm
     :prompt "Web Site: "
     :sources  `((
                  (name       . "Bookmarks")
                  (candidates . helm-url-default-url-list)
                  (action     . (lambda (c) (browse-url (cdr c))) )
                  ))))

;; Taken from: http://emacs.stackexchange.com/questions/7148/get-all-regexp-matches-in-buffer-as-a-list
(defun re-seq (regexp string)
  "Get a list of all regexp matches in a string"
  (save-match-data
    (let ((pos 0)
          matches)
      (while (string-match regexp string pos)
        (push (match-string 0 string) matches)
        (setq pos (match-end 0)))
      matches)))


(defun helm-make ()
  (interactive)
  (let ((tasks
         (re-seq "^\\w+"
                 (with-temp-buffer
                   (insert-file "Makefile")
                   (buffer-substring-no-properties
                    (point-min)
                    (point-max))))))
    (helm
     :prompt "Makefile task: "
     :sources  `((
                  (name       . "Task")
                  (candidates . ,tasks)
                  (action     . (lambda (task)
                                  (start-process  "make"
                                                  "*make*"
                                                  "make" task
                                                  ))))))
    (switch-to-buffer "*make*")))

(defun helm-make2 ()
  (interactive)
  (flet ((re-seq2 (regexp string) (save-match-data
                                    (let ((pos 0)
                                          matches)
                                      (while (string-match regexp string pos)
                                        (push (match-string 0 string) matches)
                                        (setq pos (match-end 0)))
                                      matches))))
    (let ((tasks    (re-seq2 "^\\w+"
                            (with-temp-buffer
                              (insert-file "Makefile")
                              (buffer-substring-no-properties
                               (point-min)
                               (point-max)
                               )))))
      (helm
       :prompt "Makefile task: "
       :sources  `((
                    (name       . "Task")
                    (candidates . ,tasks)
                    (action     . (lambda (task)
                                    (start-process  "make"
                                                    "*make*"
                                                    "make" task
                                                    ))))))
      (switch-to-buffer "*make*"))))

all: html

html:
        mkdir -p dist
        emacs --batch -q -l build.el --kill
        mv dist/README.html dist/index.html
        cp -r -v images dist/images
        cp -r *.org  dist/

browse:
        firefox dist/index.html

clean:
        rm -rf dist/*.html dist/*.html~

ELISP> (defun file-contents (filename)
  (interactive "fFind file: ")
  (with-temp-buffer
    (insert-file-contents filename)
    (buffer-substring-no-properties (point-min) (point-max))))
file-contents
ELISP>

ELISP> (defun write-file (filename content)
         (append-to-file content nil filename))
write-file
ELISP>

ELISP> (remove-if 'null (mapcar 'buffer-file-name  (buffer-list)))
("/home/tux/.emacs.d/init.el" "/sudo:root@localhost:/etc/host.conf")

ELISP> (setq session-file  "~/.emacs.d/lastsession.el")
"~/.emacs.d/lastsession.el"
ELISP>

ELISP>
ELISP> (format "(setq last-session-files '%S)" (remove-if 'null (mapcar 'buffer-file-name  (buffer-list))))
"(setq last-session-files '(\"/home/tux/.emacs.d/init.el\" \"/sudo:root@localhost:/etc/host.conf\"))"


ELISP> (setq code  (format "(setq last-session-files '%S)" (remove-if 'null (mapcar 'buffer-file-name  (buffer-list)))))
"(setq last-session-files '(\"/home/tux/.emacs.d/init.el\" \"/sudo:root@localhost:/etc/host.conf\"))"
ELISP>

ELISP> (setq session-file "~/.emacs.d/lastsession.el")

ELISP> (delete-file session-file)
nil

ELISP> (write-file session-file code)
nil
ELISP>

ELISP> (file-contents session-file)
"(setq last-session-files '(\"/home/tux/.emacs.d/init.el\" \"/sudo:root@localhost:/etc/host.conf\"))"
ELISP>

ELISP> (load-file session-file)
t
ELISP> last-session-files
("/home/tux/.emacs.d/init.el" "/sudo:root@localhost:/etc/host.conf")

;;; Open All files defined in Last Session
ELISP>
ELISP> (mapcar 'find-file last-session-files)
(#<buffer init.el> #<buffer host.conf>)

ELISP>

(setq session-file "~/.emacs.d/lastsession.el")

(defun write-file (filename content)
  (append-to-file content nil filename))


(defun make-session-code ()
     (interactive)
     (format "(setq last-session-files '%S)" (remove-if 'null (mapcar 'buffer-file-name  (buffer-list)))))


(defun save-session ()
    "Save Current Session"
    (interactive)
    (when (file-exists-p session-file) (delete-file session-file))
    (write-file session-file (make-session-code)))


(defun load-session ()
  (interactive)
  (load-file session-file)
  (mapcar 'find-file last-session-files)
)

(message "Reloaded")

(defun save-view ()
  "Save current window configuration"
  (interactive)
  (setq winconf  (current-window-configuration))
  (message "View Saved - Press to restore"))

(defun restore-view ()
  "Restore saved window configuration"
  (interactive)
  (set-window-configuration winconf)
  (message "View loaded"))

(global-set-key (kbd "<f7>")  #'save-view)
(global-set-key (kbd "<f8>")  #'restore-view)

(setq scratch-buffer-file "~/.emacs.d/scratch.el")

(setq initial-scratch-message "")           ;initial message
(add-hook 'kill-emacs-hook 'scratch-save)   ;
(add-hook 'window-setup-hook 'scratch-resume);

;;  window-setup-hook
;;  @see info 38.1.1 Summary: Sequence of Actions at Startup
(add-hook 'kill-buffer-hook; *scratch*
          (lambda ()
            (if (equal (buffer-name) "*scratch*") (scratch-save))))

(add-hook 'after-save-hook
          (lambda ()
            (unless (get-buffer "*scratch*") (scratch-resume))))


(defun scratch-save ()
  (let ((buf (get-buffer "*scratch*")))
    (when buf
      (set-buffer buf)
      (write-file scratch-buffer-file)
      (ignore-errors (kill-buffer "scratch.el")))))

(defun scratch-resume ()
  "*scratch* "
  (interactive)
  (set-buffer (get-buffer-create "*scratch*"))
  (funcall initial-major-mode)
  (insert-file-contents scratch-buffer-file nil nil nil t)

  (ignore-errors (kill-buffer ".scratch")))

(defun python/scan-functions ()
  (interactive)
  (split-window-horizontally)
  (occur "def"))

(defun scan-code-tags ()
     "Scan code tags: @TODO: , @FIXME:, @BUG:, @NOTE:."
     (interactive)
     (split-window-horizontally)
     (occur "@FIXME:\\|@TODO:\\|@BUG:\\|@NOTE:"))

;; Usage: M-x reload-init-file
;;
(defun reload-init-file ()
  "Reload init.el file."
  (interactive)
  (load user-init-file)
  (message "Reloaded init.el OK."))

;; Usage: M-x open-init-file
;;
(defun open-init-file ()
    (interactive)
    (find-file user-init-file))

(defun refresh ()
    "Revert buffer without confirmation."
    (interactive)
    (revert-buffer t t))

(defun eval-string (str) (eval (read str)))

(defun make-menu-rows ()
 (mapcar
   (lambda (x)
      (format "[\"%s\" (load-theme '%s)]"  (symbol-name x) (symbol-name x) ))
   (custom-available-themes)))


(defun make-color-menu-code ()
  (format
   "
   (easy-menu-define djcb-menu global-map \"Color Themes\"
     '(\"Color Themes\"
        %s
      )
   )
   "
  (mapconcat 'identity (make-menu-rows) "\n"))) 



;;
;; "Eval is evil". It must be avoided, because, it is hard to refactor,
;; hard to debug and vulnerable to code injection on Web Apps, so a better
;; way to write it is to use Elisp macros.
;;
;; @DONE: Change eval-string to an Elisp macro.
;;
(eval-string (make-color-menu-code))

ELISP> (custom-available-themes)
(cyberpunk adwaita deeper-blue dichromacy leuven light-blue manoj-dark misterioso tango-dark tango tsdh-dark tsdh-light wheatgrass whiteboard wombat)

ELISP> (mapcar
        (lambda (sym) `[,(symbol-name sym) (load-theme (quote ,sym))])
        (custom-available-themes)
    )
(["adwaita"
  (load-theme 'adwaita)]
 ["deeper-blue"
  (load-theme 'deeper-blue)]
 ["dichromacy"
  (load-theme 'dichromacy)]
 ["leuven"
  (load-theme 'leuven)]
 ["light-blue"
  (load-theme 'light-blue)]
 ["manoj-dark"
  (load-theme 'manoj-dark)]
 ["misterioso"
  (load-theme 'misterioso)]
 ["tango-dark"
  (load-theme 'tango-dark)]
  ...

ELISP>  (defun make-menu-rows ()
          (mapcar
        (lambda (sym) `[,(symbol-name sym) (load-theme (quote ,sym))])
        (custom-available-themes)))
make-menu-rows
ELISP>
ELISP> (make-menu-rows)
(["adwaita"
  (load-theme 'adwaita)]
 ["deeper-blue"
  (load-theme 'deeper-blue)]
 ["dichromacy"
  (load-theme 'dichromacy)]
 ["leuven"
  (load-theme 'leuven)]
  ...


ELISP> `(easy-menu-define djcb-menu global-map "Color Themes"
          '("Color Themes"
           ,@(make-menu-rows)))
(easy-menu-define djcb-menu global-map "Color Themes"
  '("Color Themes"
    ["adwaita"
     (load-theme 'adwaita)]
    ["deeper-blue"
     (load-theme 'deeper-blue)]
    ["dichromacy"
     (load-theme 'dichromacy)]
    ["leuven"
     (load-theme 'leuven)]
    ["light-blue"
     (load-theme 'light-blue)]
     ...

;;; Now execute the generated code, the menu will pop up.
;;;

ELISP> (eval `(easy-menu-define djcb-menu global-map "Color Themes"
          '("Color Themes"
           ,@(make-menu-rows))))
nil

(defun make-menu-rows ()
          (mapcar
        (lambda (sym) `[,(symbol-name sym) (load-theme (quote ,sym))])
        (custom-available-themes)))


(defmacro make-color-menu ()
  `(easy-menu-define djcb-menu global-map "Color Themes"
     '("Color Themes"
       ,@(make-menu-rows))))

(make-color-menu)

;;;;; Or copy and paste the following  block on IELM shell

(progn
    (defun make-menu-rows ()
              (mapcar
            (lambda (sym) `[,(symbol-name sym) (load-theme (quote ,sym))])
            (custom-available-themes)))


    (defmacro make-color-menu ()
      `(easy-menu-define djcb-menu global-map "Color Themes"
         '("Color Themes"
           ,@(make-menu-rows))))
    (make-color-menu))


;;;; Testing the macro expansion

ELISP> (macroexpand '(make-color-menu))
(progn
  (defvar djcb-menu nil "Color Themes")
  (easy-menu-do-define 'djcb-menu global-map "Color Themes"
               '("Color Themes"
             ["adwaita"
              (load-theme 'adwaita)]
             ["deeper-blue"
              (load-theme 'deeper-blue)]
             ["dichromacy"
              (load-theme 'dichromacy)]
             ["leuven"
              (load-theme 'leuven)]
             ["light-blue"
              (load-theme 'light-blue)]
            ...