mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-17 c4001ccd1864293b64aa37d83a9d9457eb875e70
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.
 
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
 
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
(require 'ztree-util)
#@60 Mark files as different if their permissions are different
(defvar ztree-diff-consider-file-permissions nil (#$ . 430))
#@192 Command-line options for the diff program used as a diff backend. These options are added to default '-q' option.
Should be a list of strings.
Example:
(setq ztree-diff-options '("-w" "-i"))
(defvar ztree-diff-additional-options nil (#$ . 557))
#@75 Function which determines if the node should be excluded from comparison.
(defvar ztree-diff-model-ignore-fun nil (#$ . 808))
(make-variable-buffer-local 'ztree-diff-model-ignore-fun)
#@79 Function which should be called whenever the progress indications is updated.
(defvar ztree-diff-model-progress-fun nil (#$ . 998))
(make-variable-buffer-local 'ztree-diff-model-progress-fun)
#@22 Update the progress.
(defalias 'ztree-diff-model-update-progress #[0 "\205 \207" [ztree-diff-model-progress-fun] 1 (#$ . 1196)])
#@74 compiler-macro for inlining `ztree-diff-node-p'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-p (and (memq (type-of cl-x) cl-struct-ztree-diff-node-tags) t)) nil] 9 (#$ . 1335)])
(put 'ztree-diff-node-p 'compiler-macro 'ztree-diff-node-p--cmacro)
#@13 
 
(fn CL-X)
(defalias 'ztree-diff-node-p #[257 "\301!>\205    \302\207" [cl-struct-ztree-diff-node-tags type-of t] 3 (#$ . 1699)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ztree-diff-node-p side-effect-free error-free put ztree-diff-node cl-deftype-satisfies] 5)
#@79 compiler-macro for inlining `ztree-diff-node-parent'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-parent--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-parent (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 1)) nil] 9 (#$ . 1993)])
(put 'ztree-diff-node-parent 'compiler-macro 'ztree-diff-node-parent--cmacro)
#@327 Access slot "parent" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-parent #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1] 5 (#$ . 2425)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-parent side-effect-free t] 4)
#@82 compiler-macro for inlining `ztree-diff-node-left-path'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-left-path--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-left-path (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 2)) nil] 9 (#$ . 3048)])
(put 'ztree-diff-node-left-path 'compiler-macro 'ztree-diff-node-left-path--cmacro)
#@330 Access slot "left-path" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-left-path #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2] 5 (#$ . 3495)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-left-path side-effect-free t] 4)
#@83 compiler-macro for inlining `ztree-diff-node-right-path'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-right-path--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-right-path (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 3)) nil] 9 (#$ . 4127)])
(put 'ztree-diff-node-right-path 'compiler-macro 'ztree-diff-node-right-path--cmacro)
#@331 Access slot "right-path" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-right-path #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 3] 5 (#$ . 4579)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-right-path side-effect-free t] 4)
#@83 compiler-macro for inlining `ztree-diff-node-short-name'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-short-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-short-name (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 4)) nil] 9 (#$ . 5214)])
(put 'ztree-diff-node-short-name 'compiler-macro 'ztree-diff-node-short-name--cmacro)
#@331 Access slot "short-name" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-short-name #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4] 5 (#$ . 5666)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-short-name side-effect-free t] 4)
#@89 compiler-macro for inlining `ztree-diff-node-right-short-name'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-right-short-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-right-short-name (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 5)) nil] 9 (#$ . 6301)])
(put 'ztree-diff-node-right-short-name 'compiler-macro 'ztree-diff-node-right-short-name--cmacro)
#@337 Access slot "right-short-name" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-right-short-name #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 5] 5 (#$ . 6783)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-right-short-name side-effect-free t] 4)
#@81 compiler-macro for inlining `ztree-diff-node-children'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-children--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-children (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 6)) nil] 9 (#$ . 7436)])
(put 'ztree-diff-node-children 'compiler-macro 'ztree-diff-node-children--cmacro)
#@329 Access slot "children" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-children #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 6] 5 (#$ . 7878)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-children side-effect-free t] 4)
#@82 compiler-macro for inlining `ztree-diff-node-different'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-different--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-different (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 7)) nil] 9 (#$ . 8507)])
(put 'ztree-diff-node-different 'compiler-macro 'ztree-diff-node-different--cmacro)
#@330 Access slot "different" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.
 
(fn CL-X)
(defalias 'ztree-diff-node-different #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 7] 5 (#$ . 8954)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ztree-diff-node-different side-effect-free t defalias copy-ztree-diff-node copy-sequence] 4)
#@158 compiler-macro for inlining `make-ztree-diff-node'.
 
(fn CL-WHOLE &cl-quote &key PARENT LEFT-PATH RIGHT-PATH SHORT-NAME RIGHT-SHORT-NAME CHILDREN DIFFERENT)
(defalias 'make-ztree-diff-node--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y\211@\310>\203A\211AA\262\202.\311    >A@\203P\312\262\202.\313\314@\"\210\202.\210\315\316\317\312\f\312\f\f\f\f\f\f\f&\f\207" [plist-member :parent :left-path :right-path :short-name :right-short-name :children :different (:parent :left-path :right-path :short-name :right-short-name :children :different :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:parent :left-path :right-path :short-name :right-short-name :children :different)" cl--defsubst-expand (parent left-path right-path short-name right-short-name children different) (cl-block make-ztree-diff-node (record 'ztree-diff-node parent left-path right-path short-name right-short-name children different))] 22 (#$ . 9641)])
(put 'make-ztree-diff-node 'compiler-macro 'make-ztree-diff-node--cmacro)
#@138 Constructor for objects of type `ztree-diff-node'.
 
(fn &key PARENT LEFT-PATH RIGHT-PATH SHORT-NAME RIGHT-SHORT-NAME CHILDREN DIFFERENT)
(defalias 'make-ztree-diff-node #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y\211@\310>\203A\211AA\262\202.\311    >A@\203P\312\262\202.\313\314@\"\210\202.\210\315\316&\207" [plist-member :parent :left-path :right-path :short-name :right-short-name :children :different (:parent :left-path :right-path :short-name :right-short-name :children :different :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:parent :left-path :right-path :short-name :right-short-name :children :different)" record ztree-diff-node] 17 (#$ . 10764)])
(byte-code "\300\301\302\303#\300\207" [function-put make-ztree-diff-node side-effect-free t] 4)
#@96 Constructor for objects of type `ztree-diff-node'.
 
(fn PARENT LEFT-PATH RIGHT-PATH DIFFERENT)
(defalias 'ztree-diff-node-create #[1028 "\300\206!\203\203\300!\202\211\301\302\303\n&\207" [ztree-file-short-name record ztree-diff-node nil] 15 (#$ . 11652)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&    \207" [function-put ztree-diff-node-create side-effect-free t cl-struct-define ztree-diff-node nil cl-structure-object record ((cl-tag-slot) (parent) (left-path) (right-path) (short-name) (right-short-name) (children) (different)) cl-struct-ztree-diff-node-tags] 11)
#@78 Determine if the NODE should be excluded from comparison results.
 
(fn NODE)
(defalias 'ztree-diff-model-ignore-p #[257 "\205!\207" [ztree-diff-model-ignore-fun] 3 (#$ . 12278)])
#@66 Construct the string with contents of the NODE given.
 
(fn NODE)
(defalias 'ztree-diff-node-to-string #[257 "\301\302!>\204\303\304\305D\"\210\306H\307\211\203R\211@\310\302!>\204,\303\304\305D\"\210\311H\312\302!>\204C\303\304\305D\"\210\313H!\260\262A\266\202\202\210\314\302!>\204d\303\304\305D\"\210\311H\315\316\302    !>\204|\303\304\305 D\"\210\317H!\315\320    \302\f!>\204\226\303\304\305D\"\210 \313H!\315\321\f\302!>\204\260\303\304\305D\"\210\322H!\315\323\302!>\204\312\303\304\305D\"\210\324H!\315\325\315\260\207" [cl-struct-ztree-diff-node-tags #[257 "\211\203=\211;\203\n\207\211\301=\203\302\207\211\303=\203\304\207\211\305=\203\"\306\207\211\307=\203*\310\207\311!>\2049\312\313\314D\"\210\211\315H\207\316\207" [cl-struct-ztree-diff-node-tags new "new" diff "different" ignore "ignored" same "same" type-of signal wrong-type-argument ztree-diff-node 4 "(empty)"] 5 "\n\n(fn X)"] type-of signal wrong-type-argument ztree-diff-node 6 "" "\n   * " 4 ": " 7 "Node: " "\n" " * Parent: " 1 " * Status: " " * Left path: " 2 " * Right path: " 3 " * Children: "] 22 (#$ . 12468)])
#@121 Return the short name of the NODE given.
If the RIGHT-SIDE is true, take the right leaf
 
(fn NODE &optional RIGHT-SIDE)
(defalias 'ztree-diff-node-short-name-wrapper #[513 "\211\204\301!>\204\302\303\304D\"\210\305H\207\301!>\204&\302\303\304D\"\210\306H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4 5] 6 (#$ . 13645)])
#@51 Determines if the NODE is a directory.
 
(fn NODE)
(defalias 'ztree-diff-node-is-directory #[257 "\301!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210\306H\203.\307!\2021\307!\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2 3 file-directory-p] 6 (#$ . 14029)])
#@181 Determine the side there the file is present for NODE.
Return BOTH if the file present on both sides;
LEFT if only on the left side and
RIGHT if only on the right side.
 
(fn NODE)
(defalias 'ztree-diff-node-side #[257 "\301!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210\306H\2030\211\2030\307\2029\2038\310\2029\311\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2 3 both left right] 6 (#$ . 14369)])
#@60 Determines if NODE1 and NODE2 are equal.
 
(fn NODE1 NODE2)
(defalias 'ztree-diff-node-equal #[514 "\301!>\204\302\303\304D\"\210\305H\301!>\204!\302\303\304D\"\210\305H\230\205u\301!>\2047\302\303\304D\"\210\306H\301!>\204I\302\303\304D\"\210\306H\230\205u\301!>\204_\302\303\304D\"\210\307H\301!>\204q\302\303\304D\"\210\307H\230\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4 2 3] 7 (#$ . 14852)])
#@90 Compare files FILE1 and FILE2 using external diff.
Returns t if equal.
 
(fn FILE1 FILE2)
(defalias 'ztree-diff-model-files-equal #[514 "\303\"\204 \304\305!\210\306!\306!\307\310!8\307\310!8U\203H\2031\311\310!8\311\310!8\230\203H\312\313    \314\211\211\315\316\n\n\nD\"B&\317U\204L\320\202M\321\207" [ztree-diff-consider-file-permissions diff-command ztree-diff-additional-options ztree-same-host-p error "Compared files are not on the same host" ztree-untrampify-filename 7 file-attributes 8 apply process-file nil "-q" append 0 diff same] 15 (#$ . 15334)])
#@91 Return the list of full paths of files in a directory DIR.
Filters out . and ..
 
(fn DIR)
(defalias 'ztree-directory-files #[257 "\300\301\302\303\"\"\207" [ztree-filter #[257 "\300!\211\301\230\206\f\211\302\230?\207" [ztree-file-short-name "." ".."] 4 "\n\n(fn FILE)"] directory-files full] 6 (#$ . 15916)])
#@111 Rescan the NODE.
The node is a either a file or directory with both
left and right parts existing.
 
(fn NODE)
(defalias 'ztree-diff-model-partial-rescan #[257 "\301!\203 \302!\210\202\277\303!>\204\304\305\306D\"\210\211\211\307\310!\204\217\311\303!>\2046\304\305\306D\"\210\307H\312\"\204\217\311\303\211!>\204Q\304\305\306D\"\210\313H!>\204u\304\305\306\303!>\204n\304\305\306\nD\"\210\313HD\"\210\303!>\204\205\304\305\306D\"\210\313H\307H\312\"\203\223\312\202\274\314\303!>\204\244\304\305\306D\"\210\315H\303!>\204\270\304\305\306D\"\210\316H\"I\266\317!\207" [cl-struct-ztree-diff-node-tags ztree-diff-node-is-directory ztree-diff-node-recreate type-of signal wrong-type-argument ztree-diff-node 7 ztree-diff-model-ignore-p eql ignore 1 ztree-diff-model-files-equal 2 3 ztree-diff-node-update-all-parents-diff] 12 (#$ . 16236)])
#@197 Create a subtree with given PARENT for the given PATH.
Argument SIDE either `left' or `right' side.
Argument DIFF different status to be assigned to all created nodes.
 
(fn PARENT PATH SIDE DIFF)
(defalias 'ztree-diff-model-subtree #[1028 "\301!\302\211\203p\211@\303!\203O\304\305=\205\306=\205$$\307        $\310!>\204>\311\312\313D\"\210\211\314I\266B\262\266\202i\304\305=\205Z\306=\205b$B\262A\266\202\202\210\207" [cl-struct-ztree-diff-node-tags ztree-directory-files nil file-directory-p ztree-diff-node-create left right ztree-diff-model-subtree type-of signal wrong-type-argument ztree-diff-node 6] 14 (#$ . 17137)])
#@68 Set the diff status for the NODE based on its children.
 
(fn NODE)
(defalias 'ztree-diff-node-update-diff-from-children #[257 "\301\302!>\204\303\304\305D\"\210\306H\307\"?\205K\310\311\302!>\204*\303\304\305D\"\210\312H\313\314\315\316&\302!>\204B\303\304\305D\"\210\211\306I\262\262\207" [cl-struct-ztree-diff-node-tags eql type-of signal wrong-type-argument ztree-diff-node 7 ignore cl-reduce ztree-diff-model-update-diff 6 :initial-value same :key ztree-diff-node-different] 8 (#$ . 17814)])
#@69 Recursively update all parents diff status for the NODE.
 
(fn NODE)
(defalias 'ztree-diff-node-update-all-parents-diff #[257 "\211\301!>\204\302\303\304D\"\210\211\305H\211\262\205 \306!\210\202\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1 ztree-diff-node-update-diff-from-children] 6 (#$ . 18337)])
#@118 Get the diff status depending if OLD or NEW is not nil.
If the OLD is `ignore', do not change anything
 
(fn OLD NEW)
(defalias 'ztree-diff-model-update-diff #[514 "\300\301\"\203    \301\207\300\301\"\203\207\300\302\"\204 \300\302\"\203\"\302\207\300\303\"\203+\303\207\207" [eql ignore diff new] 5 (#$ . 18699)])
#@193 Recursively update diff status of all children of NODE.
This function will traverse through all children recursively
setting status from the NODE, unless they have an ignore status
 
(fn NODE)
(defalias 'ztree-diff-node-update-diff-from-parent #[257 "\301!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210\306H\307\310\311\312\313\314!\315\"\306\316%\"\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 7 6 mapc make-byte-code 257 "\302\300\303\"\204'\302\300\303\"\206#\302\304!    >\204\305\306\307D\"\210\310H\303\"?\205@\304!    >\2046\305\306\307D\"\210\211\211\310\300I\266\311!\207" vconcat vector [cl-struct-ztree-diff-node-tags eql ignore type-of signal wrong-type-argument ztree-diff-node 7 ztree-diff-node-update-diff-from-parent] "\n\n(fn CHILD)"] 10 (#$ . 19031)])
#@141 Find in LIST of files the file with name SHORTNAME.
If IS-DIR searching for directories; assume files otherwise
 
(fn LIST SHORTNAME IS-DIR)
(defalias 'ztree-diff-model-find-in-files #[771 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [ztree-find make-byte-code 257 "\302!\300\230\205 \301\303!=\207" vconcat vector [ztree-file-short-name file-directory-p] 4 "\n\n(fn X)"] 12 (#$ . 19887)])
#@164 Determine if the NODE and its children should be ignored.
If no parent - never ignore;
if in ignore list - ignore
if parent has ignored status - ignore
 
(fn NODE)
(defalias 'ztree-diff-model-should-ignore #[257 "\301!>\204\302\303\304D\"\210\211\305H\211\2051\306\301!>\204&\302\303\304D\"\210\307H\310\"\2061\311!\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1 eql 7 ignore ztree-diff-model-ignore-p] 7 (#$ . 20296)])
#@83 Traverse 2 paths defined in the NODE updating its children and status.
 
(fn NODE)
(defalias 'ztree-diff-node-recreate #[257 "\301\302!>\204\303\304\305D\"\210\306H!\301\302!>\204$\303\304\305D\"\210\307H!\310!\211\2033\311\2024\312\313\314 \210\203T\302!>\204M\303\304\305D\"\210\211\315\311I\266\211\203,\211@\316!\317!\320#\321 \n$\310!\203\213\302!>\204\204\303\304\305D\"\210\211\211\315\311I\266\203\230\322 \323\324$\262\n\203\323\204\323\302!>\204\257\303\304\305D\"\210\211\211\325\326    \327\302!>\204\310\303\304\305\nD\"\210\315H$I\266\202\203\204\330\302!>\204\353\303\304\305D\"\210\315H\311\"\204\302!>\204\303\304\305D\"\210\211\211\315\331\"I\266\202\203\203\332!\210\211B\262\266A\266\202\202U\210\211\203\235\211@\317!\321    \313$\310!\203[\302!>\204T\303\304\305D\"\210\211\211\315\311I\266\203\217\302!>\204n\303\304\305D\"\210\211\211\325\326\333\302!>\204\207\303\304\305\nD\"\210\315H$I\266\211B\262\266A\266\202\202.\210\204\302\302!>\204\263\303\304\305D\"\210\211\315\334\335\336\337\340\341&I\266\302!>\204\323\303\304\305D\"\210\211\325I\262\207" [cl-struct-ztree-diff-node-tags ztree-directory-files type-of signal wrong-type-argument ztree-diff-node 2 3 ztree-diff-model-should-ignore ignore new nil ztree-diff-model-update-progress 7 ztree-file-short-name file-directory-p ztree-diff-model-find-in-files ztree-diff-node-create cl-delete :test string-equal 6 ztree-diff-model-subtree left eql ztree-diff-model-files-equal ztree-diff-node-recreate right cl-reduce ztree-diff-model-update-diff :initial-value same :key ztree-diff-node-different] 23 (#$ . 20777)])
#@30 Refresh the NODE.
 
(fn NODE)
(defalias 'ztree-diff-model-update-node #[257 "\300!\207" [ztree-diff-node-recreate] 3 (#$ . 22533)])
#@212 Set the buffer-local ignore function to IGNORE-P.
Ignore function is a function of one argument (ztree-diff-node)
which returns t if the node should be ignored (like files starting
with dot etc).
 
(fn IGNORE-P)
(defalias 'ztree-diff-model-set-ignore-fun #[257 "\211\211\207" [ztree-diff-model-ignore-fun] 3 (#$ . 22672)])
#@171 Setter for the buffer-local PROGRESS-FUN callback.
This callback is called to indicate the ongoing activity.
Callback is a function without arguments.
 
(fn PROGRESS-FUN)
(defalias 'ztree-diff-model-set-progress-fun #[257 "\211\211\207" [ztree-diff-model-progress-fun] 3 (#$ . 23002)])
(provide 'ztree-diff-model)