Diff von zwei Puffern ohne temporäre Dateien zu erstellen

Ich brauche den Unterschied von zwei Puffern. Eine Möglichkeit wäre, temporäre Dateien zu erstellen, die den Inhalt dieser Puffer enthalten, und die diffFunktion zu verwenden. Die Puffer enthalten jedoch vertrauliche Informationen, und ich würde es vorziehen, diese Informationen nicht im Klartext auf der Festplatte zu haben.

Ich habe über die Verwendung von ediff nachgedacht, mit dem Puffer direkt verglichen werden können, aber ediff startet eine interaktive Sitzung und möchte diese in einem Skript verwenden.

@tmalsburg, Folgende Befehlsaufrufe unterscheiden sich in 2 Puffern ohne die Erstellung temporärer Dateien. Es werden Named Pipes verwendet, wie Sie oben vorgeschlagen haben:

(require 'diff)
(defun diff-buffers-without-temp-files (buffer1 buffer2 &optional switches)
  "Run diff program on BUFFER1 and BUFFER2.
Make the comparison without the creation of temporary files.

When called interactively with a prefix argument, prompt
interactively for diff switches.  Otherwise, the switches
specified in the variable `diff-switches' are passed to the diff command."
  (interactive
   (list (read-buffer "buffer1: " (current-buffer))
         (read-buffer "buffer2: " (current-buffer))
         (diff-switches)))
  (or switches (setq switches diff-switches))
  (unless (listp switches) (setq switches (list switches)))
  (let ((buffers (list buffer1 buffer2))
        (buf (get-buffer-create "*diff-buffers*"))
        fifos res)
    (dotimes (_ 2) (push (make-temp-name "/tmp/pipe") fifos))
    (setq fifos (nreverse fifos))
    (with-current-buffer buf (erase-buffer))
    (unwind-protect
        (progn
          (dotimes (i 2)
            (let ((cmd (format "cat > %s << EOF\n%s\nEOF"
                               (nth i fifos)
                               (with-current-buffer (nth i buffers)
                                 (buffer-string)))))
              (call-process "mkfifo" nil nil nil (nth i fifos))
              (start-process-shell-command (format "p%d" i) nil cmd)))
          (setq res (apply #'call-process diff-command nil buf nil (car fifos) (cadr fifos) switches))
          (if (zerop res)
              (message "Buffers have same content")
            (display-buffer buf)
            (with-current-buffer buf (diff-mode))
            (message "Buffer contents are different"))
          res)
      ;; Clean up.
      (dolist (x fifos)
        (and (file-exists-p x) (delete-file x))))))

1. Bei interaktivem Aufruf wird der Unterschied angezeigt, wenn die Puffer unterschiedliche Inhalte haben.

2. Beim Aufruf von Lisp wird der Exit-Code des diff-Programms zurückgegeben. Das heißt, 0, wenn die Puffer denselben Inhalt haben, andernfalls 1.

   (diff-buffers-without-temp-files (get-buffer "*scratch*") (get-buffer "*scratch*"))
   => 0
   
   
   (diff-buffers-without-temp-files (get-buffer "*scratch*") (get-buffer "*Messages*"))
   => 1
   

Getestet für Emacs Version 24.3 auf einem Computer mit Debian GNU / Linux 9.0 (Stretch).

• Der obige Code scheint zu funktionieren, wenn er von Lisp aufgerufen wird. Leider zeigt sich bei interaktiven Anrufen meistens ein abgeschnittener Unterschied.

• In der folgenden Version wird die asynchrone Bibliothek eines Drittanbieters verwendet . Die Unterschiede werden nicht abgeschnitten.

(require 'diff)
(require 'async)
(defun diff-buffers-without-temp-files (buffer1 buffer2 &optional switches)
  "Run diff program on BUFFER1 and BUFFER2.
Make the comparison without the creation of temporary files.

When called interactively with a prefix argument, prompt
interactively for diff switches.  Otherwise, the switches
specified in the variable `diff-switches' are passed to the diff command."
  (interactive
   (list (read-buffer "buffer1: " (current-buffer))
         (read-buffer "buffer2: " (current-buffer))
         (diff-switches)))
  (or switches (setq switches diff-switches))
  (unless (listp switches) (setq switches (list switches)))
  (let ((buffers (list buffer1 buffer2))
        (buf (get-buffer-create "*diff-buffers*"))
        fifos res)
    (dotimes (_ 2) (push (make-temp-name "/tmp/pipe") fifos))
    (setq fifos (nreverse fifos))
    (with-current-buffer buf (erase-buffer))
    (unwind-protect
        (progn
          (dotimes (i 2)
            (let ((cmd (format "cat > %s" (nth i fifos))))
              (call-process "mkfifo" nil nil nil (nth i fifos))
              (async-start
               `(lambda ()
                  (with-temp-buffer
                    (insert ,(with-current-buffer (nth i buffers) (buffer-string)))
                    (call-process-region
                     1 (point-max) shell-file-name nil nil nil
                     shell-command-switch ,cmd))))))
          (setq res (apply #'call-process diff-command nil buf nil (car fifos) (cadr fifos) switches))
          (if (zerop res)
              (message "Buffers have same content")
            (display-buffer buf)
            (with-current-buffer buf (diff-mode))
            (message "Buffer contents are different"))
          res)
      ;; Clean up.
      (dolist (x fifos)
        (and (file-exists-p x) (delete-file x))))))

AFAIU Emacs benötigt externe Programme, um den Diff zu machen. Zum Beispiel ediff-make-diff2-buffer, die zwei Puffer vergleichen würde, ruft intern auf

  (ediff-exec-process ediff-diff-program
                 diff-buffer
                 'synchronize
                 ediff-actual-diff-options file1 file2)

Wo ediff-diff-programkönnte die GNU / Linux darstellen diff. Mit dem neuen FFI ist das System diffmöglicherweise zugänglich. Auch eine Emacs Lisp Diff-Implementierung könnte den Job erledigen.

Wie wäre es, wenn Sie den Befehl shell verwenden, um diff aufzurufen und ihm einen Ausgabepuffer zu übergeben? Oder Shell-Befehl-zu-Zeichenfolge, um den Unterschied in einer Zeichenfolge zu erhalten

Wenn Sie mit Ediff einverstanden sind, reicht dies aus:

(defun my/diff-buffers (buffer-A buffer-B)
  "Run Ediff on a pair of buffers, BUFFER-A and BUFFER-B."
  (ediff-buffers-internal buffer-A buffer-B nil nil 'ediff-buffers))

und nenne es so:

(my/diff-buffers "*temp*" "*temp*<2>")