Comments on: Emacs Utility Functions

By: Jared

Jared — Sat, 01 Aug 2009 07:52:46 +0000

Hi dim,

Everyone should have a version of duplicate-current-line And I really should take one of these fixed version.

By the way, there is a dotimes macro in cl.el which you can use instead of your (while (> n 0) …)

By: dim

dim — Fri, 31 Jul 2009 21:49:55 +0000

Hi,

Reading your blog entry made me think I need a duplicate-current-line function, and one that works even when point is into last buffer’s line

I’m fond of elisp, some minutes later I’m enjoying this:

;; duplicate current line
(defun duplicate-current-line (&optional n)
“duplicate current line, make more than 1 copy given a numeric argument”
(interactive “p”)
(save-excursion
(let ((nb (or n 1))
(current-line (thing-at-point ‘line)))
;; when on last line, insert a newline first
(when (or (= 1 (forward-line 1)) (eq (point) (point-max)))
(insert “\n”))

;; now insert as many time as requested
(while (> n 0)
(insert current-line)
(setq n (- n 1))))))

(global-set-key (kbd “C-S-d”) ‘duplicate-current-line)

By: Jared

Jared — Tue, 28 Jul 2009 19:38:25 +0000

Hi Alex,

Thanks for the list. I have a version of chomp that looks remarkably similar myself

And I found Ruslan’s nice htmlize snippet in a previous link round-up.

Cheers

By: Alex Bennee

Alex Bennee — Mon, 27 Jul 2009 08:11:44 +0000

A couple from my .emacs, first a bunch of string munging functions:

;; String munging functions
;
; Extract the first group in a regex

(defun extract-string(regex string)
  "Extract a string in a regex (the bit in ()'s)"
  (interactive)
  (let ((s string)) (if (string-match regex s) (match-string 1 s) s)))

; And building on that
(defun extract-value-from-pair(key string)
  "Extract the value from AAAA=value pairs"
  (let ((regex (concat key "=\\(.*\\)$")))
    (extract-string regex string)))

; examples:
;  (extract-string "name is \\(\.*\\) " "my name is Alex ok") = Alex
;  (extract-value-from-pair "AAA" "AAA=xxx") = xxx

; chomp
(defun chomp(string)
  "Perform a perl-like chomp"
  (let ((s string)) (if (string-match "\\(.*\\)\n" s) (match-string 1 s) s)))

I also have a rather ugly "which" implementation which I'm sure could be nicer.

;; which-lookup
;
; Like the shell command of the same name except it trims to 'nil if
; it can't find anything

(defun which-lookup(name)
  "Perform a `which` like file look-up"
  (let
      ((file (chomp
              (shell-command-to-string
               (concat "which " name)))))
    (if (and (file-exists-p file) (> (length file) 0))
        (concat file)
      ())))

And finally the borrowed script that brings you the formatting of this posting.

      ; From http://ruslanspivak.com/2007/08/18/htmlize-your-erlang-code-buffer/
      (defun my-htmlize-region (beg end)
        "Htmlize region and put into  tag style that is left in  tag
plus add font-size: 8pt"
        (interactive "r")
        (let* ((buffer-faces (htmlize-faces-in-buffer))
               (face-map (htmlize-make-face-map (adjoin 'default buffer-faces)))
               (pre-tag (format
                         ""
                         (mapconcat #'identity (htmlize-css-specs
                                                (gethash 'default face-map)) " ")))
               (htmlized-reg (htmlize-region-for-paste beg end)))
          (switch-to-buffer-other-window "*htmlized output*")
                                        ; clear buffer
          (kill-region (point-min) (point-max))
                                        ; set mode to have syntax highlighting
          (nxml-mode)
          (save-excursion
            (insert htmlized-reg))
          (while (re-search-forward "" nil t)
            (replace-match pre-tag nil nil))
          (goto-char (point-min))))

By: Jared

Jared — Sun, 26 Jul 2009 20:29:14 +0000

I knew I'd learn something from posting this, thanks Ian. (I'm slightly surprised about identity as I thought I'd looked for it, but not about the rest).

By: Ian Eure

Ian Eure — Sun, 26 Jul 2009 18:02:39 +0000

I don’t know why you’d want `identity’, since it’s a C builtin:
`identity is a built-in function in `C source code’.
(identity arg)
Return the argument unchanged.’

You might also look at `normal-top-level-add-subdirs-to-load-path’, which adds all subdirectories of a path to load-path. You can just point it at your lisp folder and you don’t have to worry about maintaining the load-path anymore.

ELisp also has `delete-dups’, and there’s `delete-duplicates’ in cl.el. Both alter the source list. There’s `remove-duplicates’ (also in cl.el), which returns a copy with dupes removed. And more generally, there’s `remove-if’.

Here’s my duplicate-line, which will DTRT, at least for me:

(defun duplicate-line (&optional arg)
“Duplicate the current line to the line below”
(interactive “p”)
(let ((beg (line-beginning-position))
(end (line-end-position arg)))
(goto-char end)
(newline)
(insert (buffer-substring beg end))))

The string-repeat implementation can be rewritten as well:

(defun string-repeat (str n)
(apply ‘concat (make-list n str)))