shell-CLI for Emacs

shell-CLI for Emacs

[Emanuel Berg]

I have done some experimentation on the "Emacs-shell-CLI" I've
been thinking about (as opposed to the current "M-x-CLI").

I would be very happy if you offered your comments on this idea
(and code).

To try out the below code:

1. Hit M-i to bring up the prompt string.
2. Type "man emacs".
3. Hit RET.

(defun string-to-cmd (str)
  (interactive "s $> ")
  (let*((cmd-and-args (split-string str " "))
        (cmd  (car cmd-and-args))
        (args (cdr cmd-and-args)))
    (eval `(,(read cmd) ,@args) )))
(define-key (current-global-map) (kbd "M-i") 'string-to-cmd)

-- 
Emanuel Berg - programmer (hire me! CV below)
computer projects: http://user.it.uu.se/~embe8573
internet activity: http://home.student.uu.se/embe8573

Re: shell-CLI for Emacs

[Barry OReilly]

> (defun string-to-cmd (str)
>   (interactive "s $> ")
>   (let*((cmd-and-args (split-string str " "))
>         (cmd  (car cmd-and-args))
>         (args (cdr cmd-and-args)))
>     (eval `(,(read cmd) ,@args) )))

Clearer than (eval `(,(read cmd) ,@args) ) is (apply (read cmd) args)

Re: shell-CLI for Emacs

[Emanuel Berg]

Barry OReilly <gundaetiapo@gmail.com> writes:

> Clearer than (eval `(,(read cmd) ,@args) ) is (apply (read cmd)
> args)

Absolutely! I didn't know of apply.

I realized a major problem with the interface is that a lot of
commands act differently depending on if there is a region or
not. An example is replace-string. With the function in the OP,
the region is ignored! Very confusing, as intuitively, once set,
you expect it to delimit the search-and-replace.

I worked around that with an, eh, interface to replace-string.

But that's getting tedious if it has to be done for a lot of
functions...

(defun rs (from to)
  (interactive)
  (let*((scope (if mark-active
                   (list (region-beginning) (region-end))
                   (list (point-min) (point-max)) ))
        (start (car   scope))
        (end   (nth 1 scope)) )
  (save-excursion
    (replace-string from to t start end) )))

-- 
Emanuel Berg - programmer (hire me! CV below)
computer projects: http://user.it.uu.se/~embe8573
internet activity: http://home.student.uu.se/embe8573

Re: shell-CLI for Emacs

[Thien-Thi Nguyen]

[-- Attachment #1: Type: text/plain, Size: 1249 bytes --]

() Emanuel Berg <embe8573@student.uu.se>
() Sat, 24 Aug 2013 00:42:50 +0200

   But that's getting tedious if it has to be done for a lot of
   functions...

Maybe you can play w/ ‘call-interactively’ and ‘unread-command-events’.
Split the line as before but instead of ‘apply’ing the command to the
args, push the args (character by character, in reverse order) onto
‘unread-command-events’, preceding each arg (set) with ‘C-j’ (newline).
Here's a test command:

 (defun zow (string symbol number)
   (interactive "sString: \nSSymbol: \nnNumber: ")
   (message "got: %S" (list string symbol number)))

Invoked like:

 zow not quite 42

it should display:

 got: ("not" quite 42)

in the echo area.  Of course, this technique loses w/ certain (stealthy)
‘interactive’ specs, regions, stateful (history var) defaults, args that
include a space, etc, but it might be fun to try, anyway.  That's the
primary benefit of all DWIM hacking, after all, for both you and Emacs!

-- 
Thien-Thi Nguyen
   GPG key: 4C807502
   (if you're human and you know it)
      read my lisp: (responsep (questions 'technical)
                               (not (via 'mailing-list)))
                     => nil

[-- Attachment #2: Type: application/pgp-signature, Size: 197 bytes --]

Re: shell-CLI for Emacs

[Emanuel Berg]

Thien-Thi Nguyen <ttn@gnu.org> writes:

> Maybe you can play w/ ‘call-interactively’ and
> ‘unread-command-events’.  Split the line as before but instead
> of ‘apply’ing the command to the args, push the args (character
> by character, in reverse order) onto ‘unread-command-events’,
> preceding each arg (set) with ‘C-j’ (newline).

Yes... that was a good idea. Impressive to say the least.

(require 'cl)
(defvar *ps* " $> ")

(defun string-to-cmd (str)
  (interactive (list (read-string *ps*)))
  (let*((cmd-and-args (split-string str " "))
        (cmd  (read (car cmd-and-args)))
        (args (cdr cmd-and-args)))
    (dolist (arg (nreverse args))
      (push 10 unread-command-events)
      (dolist (n (reverse (string-to-list arg)))
        (push n unread-command-events) ))
    (call-interactively cmd) ))
(define-key (current-global-map) (kbd "M-i") 'string-to-cmd)

Works for your zow test function, 'man emacs', and you don't have
to rewrite replace-string.

-- 
Emanuel Berg - programmer (hire me! CV below)
computer projects: http://user.it.uu.se/~embe8573
internet activity: http://home.student.uu.se/embe8573

Re: shell-CLI for Emacs

[Emanuel Berg]

Thien-Thi Nguyen <ttn@gnu.org> writes:

> Of course, this technique loses w/ certain (stealthy)
> ‘interactive’ specs ‘interactive’ specs, regions ...

replace-string works with and without a region, when I did exactly
as you told me. But perhaps there is more to regions?

> stateful (history var) defaults

What's that? :)

> args that include a space

I got that solved. Now,

replace-string 'Hello all!' 'Dear all,'

works.

The code [1] got somewhat complicated...

> That's the primary benefit of all DWIM hacking, after all, for
> both you and Emacs!

DWIM, is that what I'm doing? Why did you say that? I'm to read
the Wikipedia article tonight - never heard of it, but intuitively
I like it.

Some people take pride in memorizing and understanding complex
command, drawing oh's and ah's from the crowd: what wizardry! I
think that's just silly. In a nutshell, this is what my system
looks like:

add_dic () { sudo tar -xvjf $1 -C /usr/share/stardict/dic; }

That's why Captain Picard say "Engage!", and not "Set the
thrusters to blaha blaha, align the ship to etc. etc., then..."

(Perhaps that's unrelated to DWIM.)

[1]

(require 'cl)
(defvar *ps* " $> ")

(defun string-to-cmd (str)
  (interactive (list (read-string *ps*)))
  (let*((cmd  (read (car (split-string str " "))))
        (args (cdr (make-arg-list (string-to-list str)))) )
    (dolist (arg (nreverse args))
      (push 13 unread-command-events) ; 13 is RET
      (dolist (n (reverse (string-to-list arg)))
        (push n unread-command-events) ))
    (call-interactively cmd) ))
(define-key (current-global-map) (kbd "M-i") 'string-to-cmd)

(defun make-arg-list (chars)
  (interactive)
  (if chars
      (let ((WS  39) ; whitespace ( )
            (SQM 32) ;      quote (')
            (c  (car chars))
            (cs (cdr chars)) )
        (if (eq c WS) (make-word cs '() WS)
          (if (eq c SQM) (make-arg-list cs)
            (make-word chars '() SQM)) ))
  '() ))

(defun make-word (chars wd sep)
  (interactive)
  (if chars
      (let ((c  (car chars))
            (cs (cdr chars)))
        (if (eq c sep) (cons wd (make-arg-list cs))
          (make-word cs (append wd (list c)) sep)))
    (list wd) ))

-- 
Emanuel Berg - programmer (hire me! CV below)
computer projects: http://user.it.uu.se/~embe8573
internet activity: http://home.student.uu.se/embe8573

Re: shell-CLI for Emacs

[Yuri Khan]

On Mon, Aug 26, 2013 at 7:56 AM, Emanuel Berg <embe8573@student.uu.se> wrote:

>> That's the primary benefit of all DWIM hacking, after all, for
>> both you and Emacs!
>
> DWIM, is that what I'm doing? Why did you say that? I'm to read
> the Wikipedia article tonight - never heard of it, but intuitively
> I like it.
>
> add_dic () { sudo tar -xvjf $1 -C /usr/share/stardict/dic; }

What you are doing here is just programming: replacing a long precise
command with a shorter but still precise command.

DWIM is a technique of replacing a precise command with one that is in
some way imprecise. You misspell a command, something behind the
scenes corrects it for you (seen in zsh). You don’t specify a
parameter, it picks a default that is sensible for some people in some
cases, but not universally (e.g. git push).

You should be reading not Wikipedia but The Jargon File:
http://www.catb.org/~esr/jargon/html/D/DWIM.html . It explains well
why one man’s Do What I Mean is another’s Damn Warren’s Infernal
Machine.

Re: shell-CLI for Emacs

[Thien-Thi Nguyen]

[-- Attachment #1: Type: text/plain, Size: 1207 bytes --]

() Emanuel Berg <embe8573@student.uu.se>
() Mon, 26 Aug 2013 02:56:35 +0200

   But perhaps there is more to regions?

Perhaps.  Emacs is very dynamic and although recently it
has taken a large step away from that nature (lexbind),
i suspect there remains a good bit of irreducible magic.

This is not a very precise answer, but that's all i can say.

   > stateful (history var) defaults

   What's that? :)

(info "(emacs) Minibuffer History")
(info "(emacs) Repetition")

   > That's the primary benefit of all DWIM hacking, after all,
   > for both you and Emacs!

   DWIM, is that what I'm doing?

When you apply heuristics to input, you are doing DWIM hacking.
Initially, you think "this is algorithm, no mere heuristic", but
then a bit later, "The code got somewhat complicated..."  :-D

   Why did you say that?

It tickles me to imagine Emacs having fun (sometimes).  A very
patient friend, slinging bytes across the gap, i appreciate it.

-- 
Thien-Thi Nguyen
   GPG key: 4C807502
   (if you're human and you know it)
      read my lisp: (responsep (questions 'technical)
                               (not (via 'mailing-list)))
                     => nil

[-- Attachment #2: Type: application/pgp-signature, Size: 197 bytes --]