Get Emacs to join lines when killing lines

When I hit C-k, Emacs kills to end-of-line. When I hit C-k again, it "kills the newline" and brings the next line up. However, the next line's indentation remains intact, and you can end up with a line that has lots of spaces in the middle.

So, from this:

    previous line material
    next line material

to this:

    previous line material        next line material

I understand I can use M-^ to join lines prope开发者_Python百科rly, but that requires the cursor to be on the next line. How do I modify C-k so that when it kills the newline, also kills the next line's indentation?

For C-k I don't know, but you could use the just-one-space function to transform any number of space into juste one space (it's bound on M-space)

If you give M-^ an argument (for example C-u M-^), it will join the next line to the current line.

Here's a way to plug in the behavior (I think) you want into kill-line: when killing a newline, also kill the indentation that follows. Note that this may result in no space being present after the cursor, which is why I think I'd go with M-1 M-^ or C-k M-SPC instead.

(defadvice kill-line (around kill-indentation
                      activate compile)
  "When killing a line break, also kill any subsequent indentation."
  (let ((f-v-l (symbol-function 'forward-visible-line)))
    (flet ((forward-visible-line (arg)
             (funcall f-v-l arg)
             (skip-chars-forward " \t")))
      ad-do-it)))

I have this in my .emacs:

(defun pull-line ()
  "Pull the next line that contains anything up to the end of this one"
  (interactive)
  (save-excursion
    (end-of-line)
    (while (looking-at "[ \n\r\t]")
      (delete-char 1))
    (if (looking-back "^[[:blank:]]*[[:punct:][:alnum:]].*")
 (fixup-whitespace)
      (indent-according-to-mode))))
(global-set-key "\C-cp" 'pull-line)

It pulls the next non-blank line up to the this one, and if there is anything on this line it makes calls (fixup-whitespace) which does the right thing about 95% of the time, otherwise it indents it to what emacs thinks is the right level. I think I copied the concept from vim?

I use it all the time, anyway.

I just realized I also have this in my .emacs, it is more exactly what you want, although I forget that I have it since I use pull-line much more often. I think I stole this from emacswiki:

(defun kill-and-join-forward (&optional arg)
  "If at end of line, join with following; otherwise kill line.
Deletes whitespace at join."
  (interactive "P")
  (if (and (eolp) (not (bolp)))
      (progn
    (delete-indentation t)
    (if (looking-at " $")
        (delete-char 1)))
    (kill-line arg)))
(global-set-key "\C-k" 'kill-and-join-forward)

This will do it:

(defun my-kill-line (&optional arg)
  (interactive "P")
  (if arg
      (kill-line arg)
    (when (prog1 (eolp) (kill-line))
      (just-one-space 1))))