Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the vivid-diff Reference Manual, version 2.1.4, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 06:26:31 2022 GMT+0.
• Introduction | What vivid-diff is all about | |
• Systems | The systems documentation | |
• Files | The files documentation | |
• Packages | The packages documentation | |
• Definitions | The symbols documentation | |
• Indexes | Concepts, functions, variables and data types |
Colored object diff viewer.
Intended to be used in the test frameworks.
| name | target | output | patch | | ---------------------- | ----------- | ---------- | ----- | | cl-difflib | sequence | unix-style | * | | clos-diff | clos-object | list | * | | monkeylib-prose-diff | text-file | html | | | diff | text-file | unix-style | | | diff-match-patch | sequence | list | * | | vivid-diff | any object | colored | |
(let ((expected '(:a :b :c))
(actual '(:a "b" :c)))
(diff-print (mismatch-sexp actual expected)))
(let ((expected "Common Lisp is awesome!!")
(actual "Common lisp is awesome!!"))
(diff-print (mismatch-sexp actual expected)))
(let ((expected (alexandria:plist-hash-table '(:a "a" :b "b" :c "c")))
(actual (alexandria:plist-hash-table '(:b :b :c "c" :d "d"))))
(diff-print (mismatch-sexp actual expected)))
As the name shows, MISMATCH-SEXP
is for S-Expression, i.e. macroexpanded form.
Please note about uninterned symbols are treated as the same as expected.
(In corner cases, this behavior may be the pitfall though.)
(let ((expected (macroexpand-1 '(with-open-file (s "path") (read s))))
(actual (macroexpand-1 '(with-open-file (out "path") (read out)))))
(diff-print (mismatch-sexp actual expected)))
MIT
SBCL
CMUCL pass the test of vivid-diff
but vivid-colors
that vivid-diff
depends on does not support CMUCL.
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The vivid-diff system |
SATO Shinichi
(:git "git@github.com:hyotang666/vivid-diff")
MIT
Colored object diff viewer.
2.1.4
vivid-diff.asd (file)
vivid-diff.lisp (file)
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files |
• The vivid-diff.asd file | ||
• The vivid-diff/vivid-diff.lisp file |
Next: The vivid-diff/vivid-diff․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
/home/quickref/quicklisp/dists/quicklisp/software/vivid-diff-20220220-git/vivid-diff.asd
vivid-diff (system)
Previous: The vivid-diff․asd file, Up: Lisp files [Contents][Index]
vivid-diff (system)
vivid-diff.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The vivid-diff package |
vivid-diff.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions | ||
• Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported functions | ||
• Exported generic functions | ||
• Exported structures |
Next: Exported generic functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
# DIFF-COMPARABLE-ORIGIN
## Description:
### syntax (DIFF-COMPARABLE-ORIGIN sb-kernel:instance)
=> result
### setf
(SETF (DIFF-COMPARABLE-ORIGIN SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value
## Arguments and Values:
instance := DIFF-COMPARABLE
result := T
## Affected By:
none
## Side-Effects:
none
## Notes:
## Exceptional-Situations:
vivid-diff.lisp (file)
(setf diff-comparable-origin) (function)
vivid-diff.lisp (file)
diff-comparable-origin (function)
# DIFF-OBJECT
## Description:
Accessor for DIFF.
### syntax (DIFF-OBJECT sb-kernel:instance)
=> result
### setf
(SETF (DIFF-OBJECT SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value
## Arguments and Values:
instance := DIFF, otherwise implementation dependent condition.
“‘lisp
#?(diff-object "not diff object")
:signals condition
“‘
result := T
## Affected By:
none
## Side-Effects:
none
## Notes:
## Exceptional-Situations:
vivid-diff.lisp (file)
(setf diff-object) (function)
vivid-diff.lisp (file)
diff-object (function)
vivid-diff.lisp (file)
# MARKUP
## Description:
Markup OBJECT as DIFF.
### syntax (MARKUP object)
=> result
## Arguments and Values:
object := T
result := DIFF.
## Affected By:
none
## Side-Effects:
none
## Notes:
When *PRINT-READABLY* and *PRINT-ESCAPSE* is NIL and VIVID-COLORS:*PRINT-VIVID* is T,
and VIVID-COLORS:*VPRINT-DISPATCH* bound by :vivid-diff dispatch-table,
Colored notation is printed.
“‘lisp
#?(let ((vivid-colors:*print-vivid* t)
(vivid-colors:*vprint-dispatch* (vivid-colors:find-vprint-dispatch :vivid-diff)))
(write (markup 0) :readably nil :escape nil))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))
“‘
## Exceptional-Situations:
vivid-diff.lisp (file)
vivid-diff.lisp (file)
Next: Exported structures, Previous: Exported functions, Up: Exported definitions [Contents][Index]
# MISMATCH-SEXP
## Description:
If S-Expression is mismatch, DIFF object is returned,
otherwise actual is returned.
### syntax (MISMATCH-SEXP actual expected)
=> result
## Argument Precedence Order:
actual expected
## Method signature:
* MISMATCH-SEXP (ACTUAL HASH-TABLE) (EXPECTED HASH-TABLE))
* MISMATCH-SEXP (ACTUAL STANDARD-OBJECT) (EXPECTED STANDARD-OBJECT))
* MISMATCH-SEXP (ACTUAL STRUCTURE-OBJECT) (EXPECTED STRUCTURE-OBJECT))
* MISMATCH-SEXP (ACTUAL ARRAY) (EXPECTED ARRAY))
* MISMATCH-SEXP (ACTUAL VECTOR) (EXPECTED VECTOR))
* MISMATCH-SEXP (ACTUAL BIT-VECTOR) (EXPECTED BIT-VECTOR))
* MISMATCH-SEXP (ACTUAL NUMBER) (EXPECTED NUMBER))
* MISMATCH-SEXP (ACTUAL PATHNAME) (EXPECTED PATHNAME))
* MISMATCH-SEXP (ACTUAL STRING) (EXPECTED STRING))
* MISMATCH-SEXP (ACTUAL LIST) (EXPECTED LIST))
* MISMATCH-SEXP (ACTUAL SYMBOL) (EXPECTED SYMBOL))
* MISMATCH-SEXP :AROUND (ACTUAL T) (EXPECTED T))
* MISMATCH-SEXP (ACTUAL T) (EXPECTED T))
## Arguments and Values:
actual := T
expected := T
result := (or T DIFF)
## Affected By:
none
## Side-Effects:
none
## Notes:
As the name explains, MISMATCH-SEXP is for S-Expression.
i.e. macro expansion form especially uninterned symbol.
“‘lisp
#?(mismatch-sexp ’#:a ’#:b)
:satisfies (lambda (x)
(& (symbolp x)
(null (symbol-package x))
(equal "A" (symbol-name x))))
“‘
“‘lisp
#?(let ((expanded-form1 (macroexpand-1 #0=’(case 0)))
(expanded-form2 (macroexpand-1 #0#)))
(values (tree-equal expanded-form1 expanded-form2)
(tree-equal expanded-form1 (mismatch-sexp expanded-form1 expanded-form2))))
:values (nil t)
“‘
## Exceptional-Situations:
#### Numbers
“‘lisp
#?(mismatch-sexp 0 0)
=> 0
“‘
“‘lisp
#?(mismatch-sexp 0 1)
:be-the diff
“‘
“‘lisp
#?(diff-print (mismatch-sexp 0 1))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))
“‘
#### Characters
“‘lisp
#?(mismatch-sexp #\a #\b)
:be-the diff
“‘
“‘lisp
#?(diff-print (mismatch-sexp #\a #\b))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red (prin1-to-string #\a)))
“‘
#### Symbols
“‘lisp
#?(mismatch-sexp t t)
=> T
“‘
“‘lisp
#?(mismatch-sexp t nil)
:be-the diff
“‘
“‘lisp
#?(diff-print (mismatch-sexp t nil))
:outputs #.(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "T"))
“‘
“‘lisp
#?(mismatch-sexp :key nil)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":KEY")))))
“‘
“‘lisp
#?(mismatch-sexp :key ’#:uninterned)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":KEY")))))
“‘
#### List
“‘lisp
#?(mismatch-sexp ’(:a) ’(:a))
=> (:A)
, :test
“‘
“‘lisp
#?(mismatch-sexp ’(:a) ’(:b))
:satisfies (lambda (diff)
(& (typep diff ’(cons diff null))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red (prin1-to-string ’:a)))))))
“‘
Dot list.
“‘lisp
#?(mismatch-sexp ’(a) ’(a . b))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(A . ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "NIL"))))))
“‘
Lesser
“‘lisp
#?(mismatch-sexp ’(a) ’(a b))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "(A . ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "NIL"))))))
“‘
Greater
“‘lisp
#?(mismatch-sexp ’(a b) ’(a))
:satisfies (lambda (diff)
(& (typep diff ’(cons (eql a) diff))
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (equal "(A . (B))" (ppcre:regex-replace-all "\\x1B[^m]+m" output ""))
(let ((red-escape-sequence
(search (let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:make-color-string cl-colors2:+red+))
output)))
(& (< red-escape-sequence
(search cl-ansi-text:+reset-color-string+ output))))))))
“‘
#### String
“‘lisp
#?(mismatch-sexp "a" "a")
=> "a"
, :test
“‘
“‘lisp
#?(mismatch-sexp "a" "b")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"~A\""
(cl-ansi-text:red "a" :style :background)))))
“‘
Lesser
“‘lisp
#?(mismatch-sexp "a" "ab")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"a~A\""
(cl-ansi-text:red ":NULL" :effect :blink)))))
“‘
Greater
“‘lisp
#?(mismatch-sexp "ab" "a")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "\"a~A\""
(cl-ansi-text:red "b" :style :background)))))
“‘
#### Pathname
“‘lisp
#?(mismatch-sexp #P"hoge" #P"hoge")
=> #P"hoge"
, :test
“‘
“‘lisp
#?(mismatch-sexp #P"hoge" #P"fuga")
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#P\"~A\""
(cl-ansi-text:red "hoge" :style :background)))))
“‘
#### Bit-vector
“‘lisp
#?(mismatch-sexp #*1101 #*1101)
=> #*1101
, :test
“‘
“‘lisp
#?(mismatch-sexp #*1101 #*1111)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "#*1101")))))
“‘
#### Vector
“‘lisp
#?(mismatch-sexp #() #())
=> #()
, :test
“‘
type mismatch.
“‘lisp
#?(mismatch-sexp "a" #(#\a))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "\"a\"")))))
“‘
element mismatch.
“‘lisp
#?(mismatch-sexp #(hoge) #(#\a))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "HOGE"))))))
“‘
Lesser
“‘lisp
#?(mismatch-sexp #(a) #(a b))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(A ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":NULL" :effect :blink))))))
“‘
Greater
“‘lisp
#?(mismatch-sexp #(a b) #(a))
:satisfies (lambda (diff)
(& (typep diff ’(vector t *))
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#(A ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "B"))))))
“‘
#### Array
“‘lisp
#?(mismatch-sexp #0A() #0A())
=> #0A()
, :test
“‘
dimension mismatch
“‘lisp
#?(mismatch-sexp #0A() #1A())
:satisfies (lambda (diff)
(& (typep diff ’diff)
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (uiop:string-prefix-p (let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:make-color-string cl-colors2:+red+))
output)
(uiop:string-suffix-p output cl-ansi-text:+reset-color-string+)
(equal "(:DIFFERENT-DIMENSIONS :EXPECTED (0) :ACTUAL NIL #0ANIL)"
(ppcre:regex-replace-all "\\x1B[^m]+m" output ""))))))
“‘
Lesser
“‘lisp
#?(mismatch-sexp #2A((a b)) #2A((a b) (c d)))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(let ((output (with-output-to-string (out) (diff-print diff out))))
(& (uiop:string-prefix-p (let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:make-color-string cl-colors2:+red+))
output)
(uiop:string-suffix-p output cl-ansi-text:+reset-color-string+)
(equal "(:DIFFERENT-DIMENSIONS :EXPECTED (2 2) :ACTUAL (1 2) #2A((A B)))"
(ppcre:regex-replace-all "\\x1B[^m]+m" output ""))))))
“‘
“‘lisp
#?(mismatch-sexp #2A((a b)) #2A((a c)))
:satisfies (lambda (diff)
(& (typep diff ’array)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#2A((A ~A))"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "B"))))))
“‘
#### Strucuture
“‘lisp
#?(mismatch-sexp cl-colors2:+red+ cl-colors2:+red+)
=> #.cl-colors2:+red+
, :test
“‘
“‘lisp
#?(mismatch-sexp cl-colors2:+red+ cl-colors2:+blue+)
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#S(CL-COLORS2:RGB :RED ~A :GREEN 0 :BLUE ~A)"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "1"))
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red "0"))))))
“‘
#### Standard-object
“‘lisp
#?(defclass c () ((slot :initarg :slot)))
:be-the standard-class
“‘
“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c :slot :a))
:satisfies (lambda (result)
(& (typep result ’c)
(equal :a (slot-value result ’slot))))
“‘
Not bound.
“‘lisp
#?(mismatch-sexp (make-instance ’c) (make-instance ’c :slot :a))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":UNBOUND" :effect :blink))))))
“‘
Should be unbound.
“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":A"))))))
“‘
Mismatch value.
“‘lisp
#?(mismatch-sexp (make-instance ’c :slot :a) (make-instance ’c :slot :b))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<C :SLOT ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":A"))))))
“‘
#### Hash-table
“‘lisp
#?(mismatch-sexp (make-hash-table) (make-hash-table))
:equivalents (make-hash-table)
, :test
“‘
Lesser
“‘lisp
#?(mismatch-sexp (make-hash-table) (alexandria:plist-hash-table ’(:a :b)))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":MISSING" :effect :blink))))))
“‘
Greater
“‘lisp
#?(mismatch-sexp (alexandria:plist-hash-table ’(:a :b)) (make-hash-table))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":B"))))))
“‘
Mismatch value.
“‘lisp
#?(mismatch-sexp (alexandria:plist-hash-table ’(:a :b)) (alexandria:plist-hash-table ’(:a "b")))
:satisfies (lambda (diff)
(& (typep diff ’diff)
(equal (with-output-to-string (out) (diff-print diff out))
(format nil "#<HASH-TABLE :A ~A>"
(let ((cl-ansi-text:*color-mode* :8bit))
(cl-ansi-text:red ":B"))))))
“‘
vivid-diff.lisp (file)
Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
# DIFF
## Description:
Abstract structure for every DIFF object.
## Class Precedence List: (case in SBCL)
diff structure-object slot-object t
## Effective Slots:
OBJECT [Type] T
## Notes:
vivid-diff.lisp (file)
structure-object (structure)
print-object (method)
diff-object (function)
(setf diff-object) (function)
# DIFF-COMPARABLE
## Description:
Abstract diff structure for comparables.
## Class Precedence List: (case in SBCL) diff-comparable diff structure-object slot-object t
## Effective Slots:
ORIGIN [Type] T
OBJECT [Type] T
## Notes:
vivid-diff.lisp (file)
diff (structure)
diff-comparable-origin (function)
(setf diff-comparable-origin) (function)
vivid-diff.lisp (file)
diff (structure)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal special variables | ||
• Internal functions | ||
• Internal structures |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
vivid-diff.lisp (file)
Next: Internal structures, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
vivid-diff.lisp (file)
Previous: Internal functions, Up: Internal definitions [Contents][Index]
vivid-diff.lisp (file)
diff (structure)
vivid-diff.lisp (file)
diff-comparable (structure)
vivid-diff.lisp (file)
diff-comparable (structure)
vivid-diff.lisp (file)
diff-comparable (structure)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index | ||
• Function index | ||
• Variable index | ||
• Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | F L V |
---|
Jump to: | F L V |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | (
C D F G H M N O P S V |
---|
Jump to: | (
C D F G H M N O P S V |
---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Jump to: | *
O S |
---|
Jump to: | *
O S |
---|
Previous: Variable index, Up: Indexes [Contents][Index]
Jump to: | D H N O P S V |
---|
Jump to: | D H N O P S V |
---|