Distinguishing between interactive and asynchronous shell buffers

Distinguishing between interactive and asynchronous shell buffers

[Sean McAfee]

I find that dired is a much better way of navigating around a large
directory hierarchy than staying in my shell buffer and issuing lots of
cd/ls commands.  To bring my shell buffer to a directory I've located
with dired, I wrote an interactive command
bring-last-shell-buffer-to-this-directory (aliased to "c'mere") which
locates the most-recently-used shell buffer like this:

  (let ((buffer (or (loop for buffer being the buffers
                          if (with-current-buffer buffer 
                               (eq major-mode 'shell-mode))
                          return buffer)
                    (error "No shell buffers!"))))
    ;; Issue a "cd" command in buffer that sends that shell
    ;; to the starting buffer's default-directory

This works great most of the time, but once I started an asynchronous
shell command after moving around in dired, and when I did M-x c'mere,
my routine tried to send a cd to the *Async Shell Command* buffer.

What's the best way to distinguish asynchronous shell command buffers
from interactive shell buffers?

Re: Distinguishing between interactive and asynchronous shell buffers

[Barry Margolin]

In article <m2y65ajluo.fsf@gmail.com>, Sean McAfee <eefacm@gmail.com> 
wrote:

> I find that dired is a much better way of navigating around a large
> directory hierarchy than staying in my shell buffer and issuing lots of
> cd/ls commands.  To bring my shell buffer to a directory I've located
> with dired, I wrote an interactive command
> bring-last-shell-buffer-to-this-directory (aliased to "c'mere") which
> locates the most-recently-used shell buffer like this:
> 
>   (let ((buffer (or (loop for buffer being the buffers
>                           if (with-current-buffer buffer 
>                                (eq major-mode 'shell-mode))
>                           return buffer)
>                     (error "No shell buffers!"))))
>     ;; Issue a "cd" command in buffer that sends that shell
>     ;; to the starting buffer's default-directory
> 
> This works great most of the time, but once I started an asynchronous
> shell command after moving around in dired, and when I did M-x c'mere,
> my routine tried to send a cd to the *Async Shell Command* buffer.
> 
> What's the best way to distinguish asynchronous shell command buffers
> from interactive shell buffers?

Why not just look for the buffer named "*shell*"?

-- 
Barry Margolin, barmar@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***

Re: Distinguishing between interactive and asynchronous shell buffers

[Sean McAfee]

Barry Margolin <barmar@alum.mit.edu> writes:
> In article <m2y65ajluo.fsf@gmail.com>, Sean McAfee <eefacm@gmail.com> 
> wrote:
>> What's the best way to distinguish asynchronous shell command buffers
>> from interactive shell buffers?

> Why not just look for the buffer named "*shell*"?

Because I often have multiple shell buffers open--none of which are
necessarily named "*shell*"--and I only want to target the
most-recently-accessed one.

Re: Distinguishing between interactive and asynchronous shell buffers

[Perry Smith]

On Feb 21, 2011, at 6:24 PM, Sean McAfee wrote:

> Barry Margolin <barmar@alum.mit.edu> writes:
>> In article <m2y65ajluo.fsf@gmail.com>, Sean McAfee <eefacm@gmail.com> 
>> wrote:
>>> What's the best way to distinguish asynchronous shell command buffers
>>> from interactive shell buffers?
> 
>> Why not just look for the buffer named "*shell*"?
> 
> Because I often have multiple shell buffers open--none of which are
> necessarily named "*shell*"--and I only want to target the
> most-recently-accessed one.

mode-name ?

It would be "Shell" for things started with "shell" and "Fundamental" for things done with shell-command

Re: Distinguishing between interactive and asynchronous shell buffers

[Sean McAfee]

Perry Smith <pedzsan@gmail.com> writes:
>>> In article <m2y65ajluo.fsf@gmail.com>, Sean McAfee <eefacm@gmail.com> 
>>> wrote:
>>>> What's the best way to distinguish asynchronous shell command buffers
>>>> from interactive shell buffers?

> mode-name ?
>
> It would be "Shell" for things started with "shell" and "Fundamental" for things done with shell-command

I hadn't known of that variable, but a quick test shows that its value
is also "Shell" in the buffer *Async Shell Command* after a
shell-command of "ls &".

Re: Distinguishing between interactive and asynchronous shell buffers

[Perry Smith]

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


On Feb 22, 2011, at 12:48 PM, Sean McAfee wrote:

> Perry Smith <pedzsan@gmail.com> writes:
>>>> In article <m2y65ajluo.fsf@gmail.com>, Sean McAfee <eefacm@gmail.com> 
>>>> wrote:
>>>>> What's the best way to distinguish asynchronous shell command buffers
>>>>> from interactive shell buffers?
> 
>> mode-name ?
>> 
>> It would be "Shell" for things started with "shell" and "Fundamental" for things done with shell-command
> 
> I hadn't known of that variable, but a quick test shows that its value
> is also "Shell" in the buffer *Async Shell Command* after a
> shell-command of "ls &".

Hmm... your are right:

> If COMMAND ends in ampersand, execute it asynchronously.
> The output appears in the buffer `*Async Shell Command*'.
> That buffer is in shell mode.


bummer.

So, my (oh dear, I just walked into an awful pun) advice at this point
is to look at "advice" in the lisp manual.  I've never used it but
it seems to allow you to wrap a function with some extra code.  In
that code, maybe set a buffer local variable that you could later test.

The other alternatives would be not to use & for shell-commands or look
at mode-name first.  If it is shell then look at the buffers name and
if it isn't "Async ... whatever", then its an interactive shell buffer.

Sorry to be so vague.
pedz


[-- Attachment #2: Type: text/html, Size: 2773 bytes --]

Re: Distinguishing between interactive and asynchronous shell buffers

[Sean McAfee]

Following myself up...

Sean McAfee <eefacm@gmail.com> writes:
> What's the best way to distinguish asynchronous shell command buffers
> from interactive shell buffers?

Digging into simple.el, the only difference I could find between
asynchronous and interactive shell buffers is that the former have
process sentinels associated with them when they're running; after they
finish, they of course have no process at all.  That led me to write:

(defun is-interactive-shell-buffer (buffer)
  (and (with-current-buffer buffer
         (eq major-mode 'shell-mode))
       (let ((proc (get-buffer-process buffer)))
         (and proc (not (process-sentinel proc))))))

I guess this solution could fail if an interactive shell buffer ever had
a process sentinel for some reason, but it seems OK for now.

Re: Distinguishing between interactive and asynchronous shell buffers

[Stefan Monnier]

> Digging into simple.el, the only difference I could find between
> asynchronous and interactive shell buffers is that the former have
> process sentinels associated with them when they're running; after they
> finish, they of course have no process at all.  That led me to write:

Indeed, there are very few differences between them.  Another way to
distinguish them is to look at the buffer's history: if you never type
in async-shell-command buffers, then the input history should be empty
in those buffers.  E.g. maybe checking (eq (point-min)
comint-last-input-start) will do the trick.
Another way is to check (string-match "Async" (buffer-name)).


        Stefan

Re: Distinguishing between interactive and asynchronous shell buffers

[Deniz Dogan]

2011/2/23 Stefan Monnier <monnier@iro.umontreal.ca>:
>> Digging into simple.el, the only difference I could find between
>> asynchronous and interactive shell buffers is that the former have
>> process sentinels associated with them when they're running; after they
>> finish, they of course have no process at all.  That led me to write:
>
> Indeed, there are very few differences between them.  Another way to
> distinguish them is to look at the buffer's history: if you never type
> in async-shell-command buffers, then the input history should be empty
> in those buffers.  E.g. maybe checking (eq (point-min)
> comint-last-input-start) will do the trick.
> Another way is to check (string-match "Async" (buffer-name)).
>

Aren't those methods a bit tacky?  I feel like there should be a
better way.

I barely know anything about comint/shell-mode but how about a
buffer-local variable which indicates whether or not the process is
running asynchronously?