Re: Clear trailing whitespace on save, but not at the cursor

[Aaron Meurer <asmeurer@gmail.com>]

Thanks a lot.  This does exactly what I want.  And this also has two
unexpected benefits: first, I can still force a save that includes
trailing whitespace by using M-x save-buffer instead of C-x C-s.
Second, trailing whitespace is cleared even if I haven't yet modified
the file, which was something else that bugged me.

On Thu, Mar 22, 2012 at 9:45 AM, Le Wang <l26wang@gmail.com> wrote:
> On Thu, Mar 22, 2012 at 8:13 AM, Aaron Meurer <asmeurer@gmail.com> wrote:
>>
>> Sorry, I'm still *very* new to emacs lisp (lisp in general, actually).
>>  Does this mean that it's possible to modify the above defadvice
>> function you gave above so that it actually clears it before the save,
>> but then puts it back?  The function works just fine in not clearing
>> at the cursor, but as noted, this is not quite what I want, because I
>> do *not* want to save trailing whitespace to file at all (I would
>> rather have my current annoyance).
>
>
> The defadvice solution is not ideal.  You're changing the fundamental
> behaviour of a function that could be called by other functions.  It's
> better to make your own command, this should fit all your requirements:

As I said, I'm still learning emacs lisp (and lisp in general), so
maybe you could clarify something for me.  I agree that defadvice is
not ideal.  To me, hooking at all is a bad thing.  At one point when
trying to fix this, I was playing around with adding a hook to
kill-buffer-hook.  I messed it up with a simple undefined symbol
error, and found it difficult to even exit emacs.  To me, this sort of
thing typifies why hooking is bad.

But it seems to me that the whole emacs lisp system is designed from
the ground up to do hooking (by the way, where I come from, "hooking"
is given the much auspicious name "monkey patching").  It seems that
much of the ways that I find online to do things, even official ways,
involve some kind of hooking: overwriting or adding to some private
variable, defadvice type things, adding things to "hook" variables,
and so on.  Is this view correct?  Is there a reason why this sort of
practice would not be as bad in emacs is it is in other languages
where hooking is possible.

My background is mostly in Python.  In Python, you are allowed by the
language to monkey patch wherever you want (with a few exceptions),
but it's rarely the official way to do things, and it's generally held
in the community that this is a bad way of doing things.

Or am I simply misviewing the way things work with my as of yet
limited knowledge of lisp?

Aaron Meurer

>
> (defun my-save-buffer-dtws (arg)
>   "save buffer delete trailing white space, preserve white space before
> point if point is past text"
>   (interactive "p")
>   (let ((save (when (and (looking-at "\\s-*$")
>                          (looking-back "\\s-+" (line-beginning-position) t))
>                 (match-string 0))))
>     (delete-trailing-whitespace)
>     (save-buffer arg)
>     (when save
>       (insert save)
>       (set-buffer-modified-p nil))))
>
> (global-set-key [remap save-buffer] 'my-save-buffer-dtws)
>
>
>
>>
>> Aaron Meurer
>
>
>
> --
> Le