agrostis / diff-match-patch Goto Github PK

(ql:quickload :diff-match-patch)

(defparameter *one*  "Hao Wang, logicien americain.

L'algorithme en  question  a  été  publié  en  1960  dans l'IBM Journal,
article intitule \"Toward  Mechanical Mathematics\", avec des variantes et
une  extension au calcul  des  prédicats.  Il  s'agit  ici  du  \"premier
programme\" de Wang, systeme \"P\".

Il observe que les preuves engendrées sont \"essentiellement des arbres\",
et  annonce  que  la  machine  a  démontre 220 théorèmes du  calcul  des
propositions  (tautologies)  en  3  minutes. Il en tire argument pour la
supériorité  d'une  approche  algorithmique  par  rapport à une approche
heuristique comme celle du \"Logic Theorist\" de Newell, Shaw et  Simon (à
partir de 1956 sur la machine JOHNNIAC de la Rand Corporation): un débat
qui dure encore...

Cet  algorithme  a  été popularisé par J. McCarthy, comme exemple­fanion
d'application  de LISP. Il figure dans le manuel de la première  version
de  LISP  (LISP  1,  sur IBM 704 justement, le manuel est daté  de  Mars
1960), et il a été repris dans le celebre \"LISP 1.5 Programmer's Manual\"
publié en 1962 par MIT Press, un des maîtres­livres de l'Informatique.





")

(defparameter *two*  "Hao Wang, logicien americain.

'algorithme en  question  a  été  publié  en  1960  dans l'IBM
Journal, article intitule \"Toward  Mechanical Mathematics\", avec des
variantes et une  extension au calcul  des  prédicats.  Il  s'agit
ici  du  \"premier programme\" de Wang, systeme \"P\".

L'article a été écrit en 1958, et les expériences effectuées sur IBM
704 ­ machine à lampes, 32 k  mots  de 36 bits, celle­là même qui vit
naître LISP à la même époque. Le programme  a  été écrit en assembleur
et  l'auteur estime que \"there is very little in the program that is
not straightforward\".

Il observe que les preuves engendrées sont \"essentiellement des
arbres\", et  annonce  que  la  machine  a  démontre 220 théorèmes du
calcul  des propositions  en  3  minutes. Il en tire
argument pour la supériorité  d'une  approche  algorithmique  par
rapport à une approche heuristique comme celle du \"Logic Theorist\"
de Newell, Shaw et  Simon (à partir de 1956 sur la machine JOHNNIAC de
la Rand Corporation): un débat qui dure encore...

Cet  algorithme  a  été popularisé par J. McCarthy, comme
exemple­fanion d'application  de LISP. Il figure dans le manuel de la
première  version de  LISP, et il a été repris dans le celebre
\"LISP 1.5 Programmer's Manual\" publié en 1962 par MIT Press, un des
maîtres­livres de l'Informatique.  ")

;; char diffs

(defparameter *d* (diff-match-patch:diff *one* *two*))
(assert (string= *one* (diff-match-patch:diff-origin *d*)))
(assert (string= *two* (diff-match-patch:diff-destination *d*)))

(defparameter *p*
  (diff-match-patch:make-patch *one* *two*))

(defparameter *pp*
  (with-input-from-string (inp (with-output-to-string (out)
                                 (diff-match-patch:write-chars-patch *p* out)))
    (diff-match-patch:read-chars-patch inp)))
;; (assert (equalp *p* *pp*)) ;; Why not? ;-)

(multiple-value-bind (new appliedp) (diff-match-patch:apply-patch *p* *one*)
  (assert (every (function identity) appliedp))
  (assert (string= *two* new)))

(multiple-value-bind (new appliedp) (diff-match-patch:apply-patch *pp* *one*)
  (assert (every (function identity) appliedp))
  (assert (string= *two* new)))


;; line diffs

(defparameter *onel* (split-sequence #\newline *one*))
(defparameter *twol* (split-sequence #\newline *two*))

(defparameter *l* (diff-match-patch:diff *onel* *twol* :test (function string=)))
(assert (equal *onel* (diff-match-patch:diff-origin *l*)))
(assert (equal *twol* (diff-match-patch:diff-destination *l*)))

(defparameter *q* (diff-match-patch:make-patch :diffs *l*))
(defparameter *qq*
  (with-input-from-string (inp (with-output-to-string (out)
                                  (diff-match-patch:write-lines-patch *q* out)))
    (diff-match-patch:read-lines-patch inp)))
;; (assert (equalp *q* *qq*)) ;; Why not? ;-)

(multiple-value-bind (new appliedp) (diff-match-patch:apply-patch *q* *onel*)
  (assert (every (function identity) appliedp))
  (assert (equal *twol* new)))

(multiple-value-bind (new appliedp) (diff-match-patch:apply-patch *qq* *onel*)
  (assert (every (function identity) appliedp)) ; FAILS - WHY?
  (assert (equal *twol* new)))                  ; FAILS - WHY?