New upstream version 4.7
Lev Lamberov
6 years ago
0 | 0 | language: generic |
1 | dist: trusty | |
2 | sudo: false | |
1 | 3 | |
2 | 4 | env: |
3 | 5 | matrix: |
5 | 7 | - EMACS_VERSION=emacs-24.5 |
6 | 8 | - EMACS_VERSION=emacs-25.1 |
7 | 9 | - EMACS_VERSION=emacs-25.2 |
10 | - EMACS_VERSION=emacs-25.3 | |
8 | 11 | - EMACS_VERSION=emacs-git-snapshot |
9 | 12 | - EMACS_VERSION=remacs-git-snapshot |
10 | 13 | |
11 | 14 | matrix: |
12 | 15 | allow_failures: |
13 | 16 | - env: EMACS_VERSION=remacs-git-snapshot |
17 | - env: EMACS_VERSION=emacs-git-snapshot | |
14 | 18 | |
15 | 19 | before_script: |
16 | 20 | # Install evm |
25 | 29 | # Install cask |
26 | 30 | - curl -fsSkL https://raw.github.com/cask/cask/master/go | python |
27 | 31 | - export PATH="$HOME/.cask/bin:$PATH" |
32 | # Fix cask (See https://github.com/cask/cask/issues/399#issuecomment-331640427) | |
33 | - perl -ibak -lape 's{#!/usr/bin/env python}{#!/usr/bin/python}' "$(which cask)" | |
34 | # Check that cask is finding the right emacs | |
35 | - cask emacs --version | |
28 | 36 | # Install elisp dependencies |
29 | 37 | - cask install |
30 | 38 | |
31 | 39 | script: |
32 | cask exec buttercup -L . | |
40 | - make compile | |
41 | - make test |
8 | 8 | (depends-on "memoize" "1.1") |
9 | 9 | |
10 | 10 | (development |
11 | (depends-on "flx-ido") | |
11 | 12 | (depends-on "with-simulated-input" |
12 | 13 | :git "https://github.com/DarwinAwardWinner/with-simulated-input.git" |
13 | 14 | :files ("*.el")) |
14 | (depends-on "buttercup" | |
15 | :git "https://github.com/DarwinAwardWinner/emacs-buttercup.git" | |
16 | :branch "expect-closures" | |
17 | :files ("*.el" | |
18 | ("bin" "bin/*")))) | |
15 | (depends-on "buttercup") | |
16 | (depends-on "undercover")) |
0 | 2017-08-19 Ryan C. Thompson <rct@thompsonclan.org> | |
1 | ||
2 | * ido-completing-read+.el (ido-cr+-maybe-update-blacklist): Fix a | |
3 | bug in blacklist update functionality | |
4 | ||
0 | 5 | 2017-08-13 Ryan C. Thompson <rct@thompsonclan.org> |
1 | 6 | |
2 | 7 | * ido-completing-read+.el (ido-cr+-apply-restrictions): Make |
0 | GNU GENERAL PUBLIC LICENSE | |
1 | Version 3, 29 June 2007 | |
2 | ||
3 | Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> | |
4 | Everyone is permitted to copy and distribute verbatim copies | |
5 | of this license document, but changing it is not allowed. | |
6 | ||
7 | Preamble | |
8 | ||
9 | The GNU General Public License is a free, copyleft license for | |
10 | software and other kinds of works. | |
11 | ||
12 | The licenses for most software and other practical works are designed | |
13 | to take away your freedom to share and change the works. By contrast, | |
14 | the GNU General Public License is intended to guarantee your freedom to | |
15 | share and change all versions of a program--to make sure it remains free | |
16 | software for all its users. We, the Free Software Foundation, use the | |
17 | GNU General Public License for most of our software; it applies also to | |
18 | any other work released this way by its authors. You can apply it to | |
19 | your programs, too. | |
20 | ||
21 | When we speak of free software, we are referring to freedom, not | |
22 | price. Our General Public Licenses are designed to make sure that you | |
23 | have the freedom to distribute copies of free software (and charge for | |
24 | them if you wish), that you receive source code or can get it if you | |
25 | want it, that you can change the software or use pieces of it in new | |
26 | free programs, and that you know you can do these things. | |
27 | ||
28 | To protect your rights, we need to prevent others from denying you | |
29 | these rights or asking you to surrender the rights. Therefore, you have | |
30 | certain responsibilities if you distribute copies of the software, or if | |
31 | you modify it: responsibilities to respect the freedom of others. | |
32 | ||
33 | For example, if you distribute copies of such a program, whether | |
34 | gratis or for a fee, you must pass on to the recipients the same | |
35 | freedoms that you received. You must make sure that they, too, receive | |
36 | or can get the source code. And you must show them these terms so they | |
37 | know their rights. | |
38 | ||
39 | Developers that use the GNU GPL protect your rights with two steps: | |
40 | (1) assert copyright on the software, and (2) offer you this License | |
41 | giving you legal permission to copy, distribute and/or modify it. | |
42 | ||
43 | For the developers' and authors' protection, the GPL clearly explains | |
44 | that there is no warranty for this free software. For both users' and | |
45 | authors' sake, the GPL requires that modified versions be marked as | |
46 | changed, so that their problems will not be attributed erroneously to | |
47 | authors of previous versions. | |
48 | ||
49 | Some devices are designed to deny users access to install or run | |
50 | modified versions of the software inside them, although the manufacturer | |
51 | can do so. This is fundamentally incompatible with the aim of | |
52 | protecting users' freedom to change the software. The systematic | |
53 | pattern of such abuse occurs in the area of products for individuals to | |
54 | use, which is precisely where it is most unacceptable. Therefore, we | |
55 | have designed this version of the GPL to prohibit the practice for those | |
56 | products. If such problems arise substantially in other domains, we | |
57 | stand ready to extend this provision to those domains in future versions | |
58 | of the GPL, as needed to protect the freedom of users. | |
59 | ||
60 | Finally, every program is threatened constantly by software patents. | |
61 | States should not allow patents to restrict development and use of | |
62 | software on general-purpose computers, but in those that do, we wish to | |
63 | avoid the special danger that patents applied to a free program could | |
64 | make it effectively proprietary. To prevent this, the GPL assures that | |
65 | patents cannot be used to render the program non-free. | |
66 | ||
67 | The precise terms and conditions for copying, distribution and | |
68 | modification follow. | |
69 | ||
70 | TERMS AND CONDITIONS | |
71 | ||
72 | 0. Definitions. | |
73 | ||
74 | "This License" refers to version 3 of the GNU General Public License. | |
75 | ||
76 | "Copyright" also means copyright-like laws that apply to other kinds of | |
77 | works, such as semiconductor masks. | |
78 | ||
79 | "The Program" refers to any copyrightable work licensed under this | |
80 | License. Each licensee is addressed as "you". "Licensees" and | |
81 | "recipients" may be individuals or organizations. | |
82 | ||
83 | To "modify" a work means to copy from or adapt all or part of the work | |
84 | in a fashion requiring copyright permission, other than the making of an | |
85 | exact copy. The resulting work is called a "modified version" of the | |
86 | earlier work or a work "based on" the earlier work. | |
87 | ||
88 | A "covered work" means either the unmodified Program or a work based | |
89 | on the Program. | |
90 | ||
91 | To "propagate" a work means to do anything with it that, without | |
92 | permission, would make you directly or secondarily liable for | |
93 | infringement under applicable copyright law, except executing it on a | |
94 | computer or modifying a private copy. Propagation includes copying, | |
95 | distribution (with or without modification), making available to the | |
96 | public, and in some countries other activities as well. | |
97 | ||
98 | To "convey" a work means any kind of propagation that enables other | |
99 | parties to make or receive copies. Mere interaction with a user through | |
100 | a computer network, with no transfer of a copy, is not conveying. | |
101 | ||
102 | An interactive user interface displays "Appropriate Legal Notices" | |
103 | to the extent that it includes a convenient and prominently visible | |
104 | feature that (1) displays an appropriate copyright notice, and (2) | |
105 | tells the user that there is no warranty for the work (except to the | |
106 | extent that warranties are provided), that licensees may convey the | |
107 | work under this License, and how to view a copy of this License. If | |
108 | the interface presents a list of user commands or options, such as a | |
109 | menu, a prominent item in the list meets this criterion. | |
110 | ||
111 | 1. Source Code. | |
112 | ||
113 | The "source code" for a work means the preferred form of the work | |
114 | for making modifications to it. "Object code" means any non-source | |
115 | form of a work. | |
116 | ||
117 | A "Standard Interface" means an interface that either is an official | |
118 | standard defined by a recognized standards body, or, in the case of | |
119 | interfaces specified for a particular programming language, one that | |
120 | is widely used among developers working in that language. | |
121 | ||
122 | The "System Libraries" of an executable work include anything, other | |
123 | than the work as a whole, that (a) is included in the normal form of | |
124 | packaging a Major Component, but which is not part of that Major | |
125 | Component, and (b) serves only to enable use of the work with that | |
126 | Major Component, or to implement a Standard Interface for which an | |
127 | implementation is available to the public in source code form. A | |
128 | "Major Component", in this context, means a major essential component | |
129 | (kernel, window system, and so on) of the specific operating system | |
130 | (if any) on which the executable work runs, or a compiler used to | |
131 | produce the work, or an object code interpreter used to run it. | |
132 | ||
133 | The "Corresponding Source" for a work in object code form means all | |
134 | the source code needed to generate, install, and (for an executable | |
135 | work) run the object code and to modify the work, including scripts to | |
136 | control those activities. However, it does not include the work's | |
137 | System Libraries, or general-purpose tools or generally available free | |
138 | programs which are used unmodified in performing those activities but | |
139 | which are not part of the work. For example, Corresponding Source | |
140 | includes interface definition files associated with source files for | |
141 | the work, and the source code for shared libraries and dynamically | |
142 | linked subprograms that the work is specifically designed to require, | |
143 | such as by intimate data communication or control flow between those | |
144 | subprograms and other parts of the work. | |
145 | ||
146 | The Corresponding Source need not include anything that users | |
147 | can regenerate automatically from other parts of the Corresponding | |
148 | Source. | |
149 | ||
150 | The Corresponding Source for a work in source code form is that | |
151 | same work. | |
152 | ||
153 | 2. Basic Permissions. | |
154 | ||
155 | All rights granted under this License are granted for the term of | |
156 | copyright on the Program, and are irrevocable provided the stated | |
157 | conditions are met. This License explicitly affirms your unlimited | |
158 | permission to run the unmodified Program. The output from running a | |
159 | covered work is covered by this License only if the output, given its | |
160 | content, constitutes a covered work. This License acknowledges your | |
161 | rights of fair use or other equivalent, as provided by copyright law. | |
162 | ||
163 | You may make, run and propagate covered works that you do not | |
164 | convey, without conditions so long as your license otherwise remains | |
165 | in force. You may convey covered works to others for the sole purpose | |
166 | of having them make modifications exclusively for you, or provide you | |
167 | with facilities for running those works, provided that you comply with | |
168 | the terms of this License in conveying all material for which you do | |
169 | not control copyright. Those thus making or running the covered works | |
170 | for you must do so exclusively on your behalf, under your direction | |
171 | and control, on terms that prohibit them from making any copies of | |
172 | your copyrighted material outside their relationship with you. | |
173 | ||
174 | Conveying under any other circumstances is permitted solely under | |
175 | the conditions stated below. Sublicensing is not allowed; section 10 | |
176 | makes it unnecessary. | |
177 | ||
178 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. | |
179 | ||
180 | No covered work shall be deemed part of an effective technological | |
181 | measure under any applicable law fulfilling obligations under article | |
182 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or | |
183 | similar laws prohibiting or restricting circumvention of such | |
184 | measures. | |
185 | ||
186 | When you convey a covered work, you waive any legal power to forbid | |
187 | circumvention of technological measures to the extent such circumvention | |
188 | is effected by exercising rights under this License with respect to | |
189 | the covered work, and you disclaim any intention to limit operation or | |
190 | modification of the work as a means of enforcing, against the work's | |
191 | users, your or third parties' legal rights to forbid circumvention of | |
192 | technological measures. | |
193 | ||
194 | 4. Conveying Verbatim Copies. | |
195 | ||
196 | You may convey verbatim copies of the Program's source code as you | |
197 | receive it, in any medium, provided that you conspicuously and | |
198 | appropriately publish on each copy an appropriate copyright notice; | |
199 | keep intact all notices stating that this License and any | |
200 | non-permissive terms added in accord with section 7 apply to the code; | |
201 | keep intact all notices of the absence of any warranty; and give all | |
202 | recipients a copy of this License along with the Program. | |
203 | ||
204 | You may charge any price or no price for each copy that you convey, | |
205 | and you may offer support or warranty protection for a fee. | |
206 | ||
207 | 5. Conveying Modified Source Versions. | |
208 | ||
209 | You may convey a work based on the Program, or the modifications to | |
210 | produce it from the Program, in the form of source code under the | |
211 | terms of section 4, provided that you also meet all of these conditions: | |
212 | ||
213 | a) The work must carry prominent notices stating that you modified | |
214 | it, and giving a relevant date. | |
215 | ||
216 | b) The work must carry prominent notices stating that it is | |
217 | released under this License and any conditions added under section | |
218 | 7. This requirement modifies the requirement in section 4 to | |
219 | "keep intact all notices". | |
220 | ||
221 | c) You must license the entire work, as a whole, under this | |
222 | License to anyone who comes into possession of a copy. This | |
223 | License will therefore apply, along with any applicable section 7 | |
224 | additional terms, to the whole of the work, and all its parts, | |
225 | regardless of how they are packaged. This License gives no | |
226 | permission to license the work in any other way, but it does not | |
227 | invalidate such permission if you have separately received it. | |
228 | ||
229 | d) If the work has interactive user interfaces, each must display | |
230 | Appropriate Legal Notices; however, if the Program has interactive | |
231 | interfaces that do not display Appropriate Legal Notices, your | |
232 | work need not make them do so. | |
233 | ||
234 | A compilation of a covered work with other separate and independent | |
235 | works, which are not by their nature extensions of the covered work, | |
236 | and which are not combined with it such as to form a larger program, | |
237 | in or on a volume of a storage or distribution medium, is called an | |
238 | "aggregate" if the compilation and its resulting copyright are not | |
239 | used to limit the access or legal rights of the compilation's users | |
240 | beyond what the individual works permit. Inclusion of a covered work | |
241 | in an aggregate does not cause this License to apply to the other | |
242 | parts of the aggregate. | |
243 | ||
244 | 6. Conveying Non-Source Forms. | |
245 | ||
246 | You may convey a covered work in object code form under the terms | |
247 | of sections 4 and 5, provided that you also convey the | |
248 | machine-readable Corresponding Source under the terms of this License, | |
249 | in one of these ways: | |
250 | ||
251 | a) Convey the object code in, or embodied in, a physical product | |
252 | (including a physical distribution medium), accompanied by the | |
253 | Corresponding Source fixed on a durable physical medium | |
254 | customarily used for software interchange. | |
255 | ||
256 | b) Convey the object code in, or embodied in, a physical product | |
257 | (including a physical distribution medium), accompanied by a | |
258 | written offer, valid for at least three years and valid for as | |
259 | long as you offer spare parts or customer support for that product | |
260 | model, to give anyone who possesses the object code either (1) a | |
261 | copy of the Corresponding Source for all the software in the | |
262 | product that is covered by this License, on a durable physical | |
263 | medium customarily used for software interchange, for a price no | |
264 | more than your reasonable cost of physically performing this | |
265 | conveying of source, or (2) access to copy the | |
266 | Corresponding Source from a network server at no charge. | |
267 | ||
268 | c) Convey individual copies of the object code with a copy of the | |
269 | written offer to provide the Corresponding Source. This | |
270 | alternative is allowed only occasionally and noncommercially, and | |
271 | only if you received the object code with such an offer, in accord | |
272 | with subsection 6b. | |
273 | ||
274 | d) Convey the object code by offering access from a designated | |
275 | place (gratis or for a charge), and offer equivalent access to the | |
276 | Corresponding Source in the same way through the same place at no | |
277 | further charge. You need not require recipients to copy the | |
278 | Corresponding Source along with the object code. If the place to | |
279 | copy the object code is a network server, the Corresponding Source | |
280 | may be on a different server (operated by you or a third party) | |
281 | that supports equivalent copying facilities, provided you maintain | |
282 | clear directions next to the object code saying where to find the | |
283 | Corresponding Source. Regardless of what server hosts the | |
284 | Corresponding Source, you remain obligated to ensure that it is | |
285 | available for as long as needed to satisfy these requirements. | |
286 | ||
287 | e) Convey the object code using peer-to-peer transmission, provided | |
288 | you inform other peers where the object code and Corresponding | |
289 | Source of the work are being offered to the general public at no | |
290 | charge under subsection 6d. | |
291 | ||
292 | A separable portion of the object code, whose source code is excluded | |
293 | from the Corresponding Source as a System Library, need not be | |
294 | included in conveying the object code work. | |
295 | ||
296 | A "User Product" is either (1) a "consumer product", which means any | |
297 | tangible personal property which is normally used for personal, family, | |
298 | or household purposes, or (2) anything designed or sold for incorporation | |
299 | into a dwelling. In determining whether a product is a consumer product, | |
300 | doubtful cases shall be resolved in favor of coverage. For a particular | |
301 | product received by a particular user, "normally used" refers to a | |
302 | typical or common use of that class of product, regardless of the status | |
303 | of the particular user or of the way in which the particular user | |
304 | actually uses, or expects or is expected to use, the product. A product | |
305 | is a consumer product regardless of whether the product has substantial | |
306 | commercial, industrial or non-consumer uses, unless such uses represent | |
307 | the only significant mode of use of the product. | |
308 | ||
309 | "Installation Information" for a User Product means any methods, | |
310 | procedures, authorization keys, or other information required to install | |
311 | and execute modified versions of a covered work in that User Product from | |
312 | a modified version of its Corresponding Source. The information must | |
313 | suffice to ensure that the continued functioning of the modified object | |
314 | code is in no case prevented or interfered with solely because | |
315 | modification has been made. | |
316 | ||
317 | If you convey an object code work under this section in, or with, or | |
318 | specifically for use in, a User Product, and the conveying occurs as | |
319 | part of a transaction in which the right of possession and use of the | |
320 | User Product is transferred to the recipient in perpetuity or for a | |
321 | fixed term (regardless of how the transaction is characterized), the | |
322 | Corresponding Source conveyed under this section must be accompanied | |
323 | by the Installation Information. But this requirement does not apply | |
324 | if neither you nor any third party retains the ability to install | |
325 | modified object code on the User Product (for example, the work has | |
326 | been installed in ROM). | |
327 | ||
328 | The requirement to provide Installation Information does not include a | |
329 | requirement to continue to provide support service, warranty, or updates | |
330 | for a work that has been modified or installed by the recipient, or for | |
331 | the User Product in which it has been modified or installed. Access to a | |
332 | network may be denied when the modification itself materially and | |
333 | adversely affects the operation of the network or violates the rules and | |
334 | protocols for communication across the network. | |
335 | ||
336 | Corresponding Source conveyed, and Installation Information provided, | |
337 | in accord with this section must be in a format that is publicly | |
338 | documented (and with an implementation available to the public in | |
339 | source code form), and must require no special password or key for | |
340 | unpacking, reading or copying. | |
341 | ||
342 | 7. Additional Terms. | |
343 | ||
344 | "Additional permissions" are terms that supplement the terms of this | |
345 | License by making exceptions from one or more of its conditions. | |
346 | Additional permissions that are applicable to the entire Program shall | |
347 | be treated as though they were included in this License, to the extent | |
348 | that they are valid under applicable law. If additional permissions | |
349 | apply only to part of the Program, that part may be used separately | |
350 | under those permissions, but the entire Program remains governed by | |
351 | this License without regard to the additional permissions. | |
352 | ||
353 | When you convey a copy of a covered work, you may at your option | |
354 | remove any additional permissions from that copy, or from any part of | |
355 | it. (Additional permissions may be written to require their own | |
356 | removal in certain cases when you modify the work.) You may place | |
357 | additional permissions on material, added by you to a covered work, | |
358 | for which you have or can give appropriate copyright permission. | |
359 | ||
360 | Notwithstanding any other provision of this License, for material you | |
361 | add to a covered work, you may (if authorized by the copyright holders of | |
362 | that material) supplement the terms of this License with terms: | |
363 | ||
364 | a) Disclaiming warranty or limiting liability differently from the | |
365 | terms of sections 15 and 16 of this License; or | |
366 | ||
367 | b) Requiring preservation of specified reasonable legal notices or | |
368 | author attributions in that material or in the Appropriate Legal | |
369 | Notices displayed by works containing it; or | |
370 | ||
371 | c) Prohibiting misrepresentation of the origin of that material, or | |
372 | requiring that modified versions of such material be marked in | |
373 | reasonable ways as different from the original version; or | |
374 | ||
375 | d) Limiting the use for publicity purposes of names of licensors or | |
376 | authors of the material; or | |
377 | ||
378 | e) Declining to grant rights under trademark law for use of some | |
379 | trade names, trademarks, or service marks; or | |
380 | ||
381 | f) Requiring indemnification of licensors and authors of that | |
382 | material by anyone who conveys the material (or modified versions of | |
383 | it) with contractual assumptions of liability to the recipient, for | |
384 | any liability that these contractual assumptions directly impose on | |
385 | those licensors and authors. | |
386 | ||
387 | All other non-permissive additional terms are considered "further | |
388 | restrictions" within the meaning of section 10. If the Program as you | |
389 | received it, or any part of it, contains a notice stating that it is | |
390 | governed by this License along with a term that is a further | |
391 | restriction, you may remove that term. If a license document contains | |
392 | a further restriction but permits relicensing or conveying under this | |
393 | License, you may add to a covered work material governed by the terms | |
394 | of that license document, provided that the further restriction does | |
395 | not survive such relicensing or conveying. | |
396 | ||
397 | If you add terms to a covered work in accord with this section, you | |
398 | must place, in the relevant source files, a statement of the | |
399 | additional terms that apply to those files, or a notice indicating | |
400 | where to find the applicable terms. | |
401 | ||
402 | Additional terms, permissive or non-permissive, may be stated in the | |
403 | form of a separately written license, or stated as exceptions; | |
404 | the above requirements apply either way. | |
405 | ||
406 | 8. Termination. | |
407 | ||
408 | You may not propagate or modify a covered work except as expressly | |
409 | provided under this License. Any attempt otherwise to propagate or | |
410 | modify it is void, and will automatically terminate your rights under | |
411 | this License (including any patent licenses granted under the third | |
412 | paragraph of section 11). | |
413 | ||
414 | However, if you cease all violation of this License, then your | |
415 | license from a particular copyright holder is reinstated (a) | |
416 | provisionally, unless and until the copyright holder explicitly and | |
417 | finally terminates your license, and (b) permanently, if the copyright | |
418 | holder fails to notify you of the violation by some reasonable means | |
419 | prior to 60 days after the cessation. | |
420 | ||
421 | Moreover, your license from a particular copyright holder is | |
422 | reinstated permanently if the copyright holder notifies you of the | |
423 | violation by some reasonable means, this is the first time you have | |
424 | received notice of violation of this License (for any work) from that | |
425 | copyright holder, and you cure the violation prior to 30 days after | |
426 | your receipt of the notice. | |
427 | ||
428 | Termination of your rights under this section does not terminate the | |
429 | licenses of parties who have received copies or rights from you under | |
430 | this License. If your rights have been terminated and not permanently | |
431 | reinstated, you do not qualify to receive new licenses for the same | |
432 | material under section 10. | |
433 | ||
434 | 9. Acceptance Not Required for Having Copies. | |
435 | ||
436 | You are not required to accept this License in order to receive or | |
437 | run a copy of the Program. Ancillary propagation of a covered work | |
438 | occurring solely as a consequence of using peer-to-peer transmission | |
439 | to receive a copy likewise does not require acceptance. However, | |
440 | nothing other than this License grants you permission to propagate or | |
441 | modify any covered work. These actions infringe copyright if you do | |
442 | not accept this License. Therefore, by modifying or propagating a | |
443 | covered work, you indicate your acceptance of this License to do so. | |
444 | ||
445 | 10. Automatic Licensing of Downstream Recipients. | |
446 | ||
447 | Each time you convey a covered work, the recipient automatically | |
448 | receives a license from the original licensors, to run, modify and | |
449 | propagate that work, subject to this License. You are not responsible | |
450 | for enforcing compliance by third parties with this License. | |
451 | ||
452 | An "entity transaction" is a transaction transferring control of an | |
453 | organization, or substantially all assets of one, or subdividing an | |
454 | organization, or merging organizations. If propagation of a covered | |
455 | work results from an entity transaction, each party to that | |
456 | transaction who receives a copy of the work also receives whatever | |
457 | licenses to the work the party's predecessor in interest had or could | |
458 | give under the previous paragraph, plus a right to possession of the | |
459 | Corresponding Source of the work from the predecessor in interest, if | |
460 | the predecessor has it or can get it with reasonable efforts. | |
461 | ||
462 | You may not impose any further restrictions on the exercise of the | |
463 | rights granted or affirmed under this License. For example, you may | |
464 | not impose a license fee, royalty, or other charge for exercise of | |
465 | rights granted under this License, and you may not initiate litigation | |
466 | (including a cross-claim or counterclaim in a lawsuit) alleging that | |
467 | any patent claim is infringed by making, using, selling, offering for | |
468 | sale, or importing the Program or any portion of it. | |
469 | ||
470 | 11. Patents. | |
471 | ||
472 | A "contributor" is a copyright holder who authorizes use under this | |
473 | License of the Program or a work on which the Program is based. The | |
474 | work thus licensed is called the contributor's "contributor version". | |
475 | ||
476 | A contributor's "essential patent claims" are all patent claims | |
477 | owned or controlled by the contributor, whether already acquired or | |
478 | hereafter acquired, that would be infringed by some manner, permitted | |
479 | by this License, of making, using, or selling its contributor version, | |
480 | but do not include claims that would be infringed only as a | |
481 | consequence of further modification of the contributor version. For | |
482 | purposes of this definition, "control" includes the right to grant | |
483 | patent sublicenses in a manner consistent with the requirements of | |
484 | this License. | |
485 | ||
486 | Each contributor grants you a non-exclusive, worldwide, royalty-free | |
487 | patent license under the contributor's essential patent claims, to | |
488 | make, use, sell, offer for sale, import and otherwise run, modify and | |
489 | propagate the contents of its contributor version. | |
490 | ||
491 | In the following three paragraphs, a "patent license" is any express | |
492 | agreement or commitment, however denominated, not to enforce a patent | |
493 | (such as an express permission to practice a patent or covenant not to | |
494 | sue for patent infringement). To "grant" such a patent license to a | |
495 | party means to make such an agreement or commitment not to enforce a | |
496 | patent against the party. | |
497 | ||
498 | If you convey a covered work, knowingly relying on a patent license, | |
499 | and the Corresponding Source of the work is not available for anyone | |
500 | to copy, free of charge and under the terms of this License, through a | |
501 | publicly available network server or other readily accessible means, | |
502 | then you must either (1) cause the Corresponding Source to be so | |
503 | available, or (2) arrange to deprive yourself of the benefit of the | |
504 | patent license for this particular work, or (3) arrange, in a manner | |
505 | consistent with the requirements of this License, to extend the patent | |
506 | license to downstream recipients. "Knowingly relying" means you have | |
507 | actual knowledge that, but for the patent license, your conveying the | |
508 | covered work in a country, or your recipient's use of the covered work | |
509 | in a country, would infringe one or more identifiable patents in that | |
510 | country that you have reason to believe are valid. | |
511 | ||
512 | If, pursuant to or in connection with a single transaction or | |
513 | arrangement, you convey, or propagate by procuring conveyance of, a | |
514 | covered work, and grant a patent license to some of the parties | |
515 | receiving the covered work authorizing them to use, propagate, modify | |
516 | or convey a specific copy of the covered work, then the patent license | |
517 | you grant is automatically extended to all recipients of the covered | |
518 | work and works based on it. | |
519 | ||
520 | A patent license is "discriminatory" if it does not include within | |
521 | the scope of its coverage, prohibits the exercise of, or is | |
522 | conditioned on the non-exercise of one or more of the rights that are | |
523 | specifically granted under this License. You may not convey a covered | |
524 | work if you are a party to an arrangement with a third party that is | |
525 | in the business of distributing software, under which you make payment | |
526 | to the third party based on the extent of your activity of conveying | |
527 | the work, and under which the third party grants, to any of the | |
528 | parties who would receive the covered work from you, a discriminatory | |
529 | patent license (a) in connection with copies of the covered work | |
530 | conveyed by you (or copies made from those copies), or (b) primarily | |
531 | for and in connection with specific products or compilations that | |
532 | contain the covered work, unless you entered into that arrangement, | |
533 | or that patent license was granted, prior to 28 March 2007. | |
534 | ||
535 | Nothing in this License shall be construed as excluding or limiting | |
536 | any implied license or other defenses to infringement that may | |
537 | otherwise be available to you under applicable patent law. | |
538 | ||
539 | 12. No Surrender of Others' Freedom. | |
540 | ||
541 | If conditions are imposed on you (whether by court order, agreement or | |
542 | otherwise) that contradict the conditions of this License, they do not | |
543 | excuse you from the conditions of this License. If you cannot convey a | |
544 | covered work so as to satisfy simultaneously your obligations under this | |
545 | License and any other pertinent obligations, then as a consequence you may | |
546 | not convey it at all. For example, if you agree to terms that obligate you | |
547 | to collect a royalty for further conveying from those to whom you convey | |
548 | the Program, the only way you could satisfy both those terms and this | |
549 | License would be to refrain entirely from conveying the Program. | |
550 | ||
551 | 13. Use with the GNU Affero General Public License. | |
552 | ||
553 | Notwithstanding any other provision of this License, you have | |
554 | permission to link or combine any covered work with a work licensed | |
555 | under version 3 of the GNU Affero General Public License into a single | |
556 | combined work, and to convey the resulting work. The terms of this | |
557 | License will continue to apply to the part which is the covered work, | |
558 | but the special requirements of the GNU Affero General Public License, | |
559 | section 13, concerning interaction through a network will apply to the | |
560 | combination as such. | |
561 | ||
562 | 14. Revised Versions of this License. | |
563 | ||
564 | The Free Software Foundation may publish revised and/or new versions of | |
565 | the GNU General Public License from time to time. Such new versions will | |
566 | be similar in spirit to the present version, but may differ in detail to | |
567 | address new problems or concerns. | |
568 | ||
569 | Each version is given a distinguishing version number. If the | |
570 | Program specifies that a certain numbered version of the GNU General | |
571 | Public License "or any later version" applies to it, you have the | |
572 | option of following the terms and conditions either of that numbered | |
573 | version or of any later version published by the Free Software | |
574 | Foundation. If the Program does not specify a version number of the | |
575 | GNU General Public License, you may choose any version ever published | |
576 | by the Free Software Foundation. | |
577 | ||
578 | If the Program specifies that a proxy can decide which future | |
579 | versions of the GNU General Public License can be used, that proxy's | |
580 | public statement of acceptance of a version permanently authorizes you | |
581 | to choose that version for the Program. | |
582 | ||
583 | Later license versions may give you additional or different | |
584 | permissions. However, no additional obligations are imposed on any | |
585 | author or copyright holder as a result of your choosing to follow a | |
586 | later version. | |
587 | ||
588 | 15. Disclaimer of Warranty. | |
589 | ||
590 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY | |
591 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT | |
592 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY | |
593 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, | |
594 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
595 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM | |
596 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF | |
597 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. | |
598 | ||
599 | 16. Limitation of Liability. | |
600 | ||
601 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING | |
602 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS | |
603 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY | |
604 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE | |
605 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF | |
606 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD | |
607 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), | |
608 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF | |
609 | SUCH DAMAGES. | |
610 | ||
611 | 17. Interpretation of Sections 15 and 16. | |
612 | ||
613 | If the disclaimer of warranty and limitation of liability provided | |
614 | above cannot be given local legal effect according to their terms, | |
615 | reviewing courts shall apply local law that most closely approximates | |
616 | an absolute waiver of all civil liability in connection with the | |
617 | Program, unless a warranty or assumption of liability accompanies a | |
618 | copy of the Program in return for a fee. | |
619 | ||
620 | END OF TERMS AND CONDITIONS | |
621 | ||
622 | How to Apply These Terms to Your New Programs | |
623 | ||
624 | If you develop a new program, and you want it to be of the greatest | |
625 | possible use to the public, the best way to achieve this is to make it | |
626 | free software which everyone can redistribute and change under these terms. | |
627 | ||
628 | To do so, attach the following notices to the program. It is safest | |
629 | to attach them to the start of each source file to most effectively | |
630 | state the exclusion of warranty; and each file should have at least | |
631 | the "copyright" line and a pointer to where the full notice is found. | |
632 | ||
633 | <one line to give the program's name and a brief idea of what it does.> | |
634 | Copyright (C) <year> <name of author> | |
635 | ||
636 | This program is free software: you can redistribute it and/or modify | |
637 | it under the terms of the GNU General Public License as published by | |
638 | the Free Software Foundation, either version 3 of the License, or | |
639 | (at your option) any later version. | |
640 | ||
641 | This program is distributed in the hope that it will be useful, | |
642 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
643 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
644 | GNU General Public License for more details. | |
645 | ||
646 | You should have received a copy of the GNU General Public License | |
647 | along with this program. If not, see <http://www.gnu.org/licenses/>. | |
648 | ||
649 | Also add information on how to contact you by electronic and paper mail. | |
650 | ||
651 | If the program does terminal interaction, make it output a short | |
652 | notice like this when it starts in an interactive mode: | |
653 | ||
654 | <program> Copyright (C) <year> <name of author> | |
655 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. | |
656 | This is free software, and you are welcome to redistribute it | |
657 | under certain conditions; type `show c' for details. | |
658 | ||
659 | The hypothetical commands `show w' and `show c' should show the appropriate | |
660 | parts of the General Public License. Of course, your program's commands | |
661 | might be different; for a GUI interface, you would use an "about box". | |
662 | ||
663 | You should also get your employer (if you work as a programmer) or school, | |
664 | if any, to sign a "copyright disclaimer" for the program, if necessary. | |
665 | For more information on this, and how to apply and follow the GNU GPL, see | |
666 | <http://www.gnu.org/licenses/>. | |
667 | ||
668 | The GNU General Public License does not permit incorporating your program | |
669 | into proprietary programs. If your program is a subroutine library, you | |
670 | may consider it more useful to permit linking proprietary applications with | |
671 | the library. If this is what you want to do, use the GNU Lesser General | |
672 | Public License instead of this License. But first, please read | |
673 | <http://www.gnu.org/philosophy/why-not-lgpl.html>. |
0 | ELISP_FILES := $(shell cask files) | |
1 | ELC_FILES := $(patsubst %.el,%.elc,$(ELISP_FILES)) | |
2 | ||
3 | .PHONY: test compile clean | |
4 | .INTERMEDIATE: .compile.intermediate | |
5 | ||
6 | all: test | |
7 | ||
8 | # We run clean-elc because undercover.el doesn't support elc files | |
9 | test: | |
10 | cask clean-elc | |
11 | cask exec buttercup -L . | |
12 | ||
13 | compile: $(ELC_FILES) | |
14 | ||
15 | $(ELC_FILES): .compile.intermediate | |
16 | .compile.intermediate: $(ELISP_FILES) | |
17 | cask build | |
18 | ||
19 | clean: | |
20 | cask clean-elc |
0 | 0 | # ido-completing-read+ (formerly ido-ubiquitous) # |
1 | 1 | |
2 | [![Build Status](https://travis-ci.org/DarwinAwardWinner/ido-completing-read-plus.svg?branch=master)](https://travis-ci.org/DarwinAwardWinner/ido-completing-read-plus) | |
3 | 2 | [![MELPA Stable](https://stable.melpa.org/packages/ido-ubiquitous-badge.svg)](https://stable.melpa.org/#/ido-ubiquitous) |
4 | 3 | [![Join the chat at https://gitter.im/DarwinAwardWinner/ido-ubiquitous](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/DarwinAwardWinner/ido-ubiquitous?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) |
5 | ||
6 | Gimme some ido... everywhere! This package replaces stock emacs | |
7 | completion with ido completion wherever it is possible to do so | |
8 | without breaking things. | |
4 | [![Build Status](https://travis-ci.org/DarwinAwardWinner/ido-completing-read-plus.svg?branch=master)](https://travis-ci.org/DarwinAwardWinner/ido-completing-read-plus) | |
5 | [![Coverage Status](https://coveralls.io/repos/github/DarwinAwardWinner/ido-completing-read-plus/badge.svg?branch=master)](https://coveralls.io/github/DarwinAwardWinner/ido-completing-read-plus?branch=master) | |
6 | ||
7 | This package replaces stock emacs completion with ido completion | |
8 | wherever it is possible to do so without breaking things (i.e. what | |
9 | you were probably hoping for when you set `ido-everywhere` to `t`). | |
9 | 10 | |
10 | 11 | Get it from MELPA: https://stable.melpa.org/#/ido-completing-read+ |
11 | 12 |
4 | 4 | ;; Filename: ido-completing-read+.el |
5 | 5 | ;; Author: Ryan Thompson |
6 | 6 | ;; Created: Sat Apr 4 13:41:20 2015 (-0700) |
7 | ;; Version: 4.5 | |
7 | ;; Version: 4.7 | |
8 | 8 | ;; Package-Requires: ((emacs "24.4") (cl-lib "0.5") (s "0.1") (memoize "1.1")) |
9 | 9 | ;; URL: https://github.com/DarwinAwardWinner/ido-completing-read-plus |
10 | 10 | ;; Keywords: ido, completion, convenience |
76 | 76 | ;; |
77 | 77 | ;;; Code: |
78 | 78 | |
79 | (defconst ido-completing-read+-version "4.5" | |
79 | (defconst ido-completing-read+-version "4.7" | |
80 | 80 | "Currently running version of ido-completing-read+. |
81 | 81 | |
82 | 82 | Note that when you update ido-completing-read+, this variable may |
83 | 83 | not be updated until you restart Emacs.") |
84 | 84 | |
85 | 85 | (require 'ido) |
86 | (require 'minibuf-eldef) | |
86 | 87 | (require 'cl-lib) |
87 | 88 | (require 'cus-edit) |
88 | 89 | (require 's) |
89 | 90 | (require 'memoize) |
91 | ||
92 | ;; Silence some byte-compiler warnings | |
93 | (eval-when-compile | |
94 | (require 'minibuf-eldef) | |
95 | (require 'flx-ido nil t)) | |
90 | 96 | |
91 | 97 | ;;; Debug messages |
92 | 98 | |
136 | 142 | (define-ido-internal-var ido-require-match) |
137 | 143 | (define-ido-internal-var ido-process-ignore-lists) |
138 | 144 | |
145 | ;; Vars and functions from flx-ido package | |
146 | (defvar flx-ido-mode) | |
147 | (declare-function flx-ido-reset "ext:flx-ido.el") | |
148 | ||
139 | 149 | ;;;###autoload |
140 | 150 | (defvar ido-cr+-minibuffer-depth -1 |
141 | 151 | "Minibuffer depth of the most recent ido-cr+ activation. |
170 | 180 | |
171 | 181 | This allows ido-cr+ to update the set of completion candidates |
172 | 182 | dynamically.") |
173 | ||
174 | (defvar ido-cr+-previous-dynamic-update-texts nil | |
175 | "Values of `ido-text' for the last few dynamic collection updates. | |
176 | ||
177 | This is used in `ido-cr+-update-dynamic-collection' as an LRU | |
178 | cache of recent values of `ido-text' in order to skip re-checking | |
179 | prefixes of these strings.") | |
180 | 183 | |
181 | 184 | (defvar ido-cr+-dynamic-update-idle-time 0.25 |
182 | 185 | "Time to wait before updating dynamic completion list.") |
403 | 406 | (defsubst ido-cr+-active () |
404 | 407 | "Returns non-nil if ido-cr+ is currently using the minibuffer." |
405 | 408 | (>= ido-cr+-minibuffer-depth (minibuffer-depth))) |
406 | ||
407 | (defsubst ido-cr+-default-was-provided () | |
408 | "Returns non-nil if ido-cr+ was passed a non-nil default argument." | |
409 | (and (nth 6 ido-cr+-orig-completing-read-args))) | |
410 | 409 | |
411 | 410 | (defun ido-cr+--called-from-completing-read () |
412 | 411 | "Returns non-nil if the most recent call to ido-cr+ was from `completing-read'." |
486 | 485 | (ido-cr+-orig-completing-read-args |
487 | 486 | (list prompt collection predicate require-match |
488 | 487 | initial-input hist def inherit-input-method)) |
489 | ;; Need to save this since activating the minibuffer once will | |
490 | ;; clear out any temporary minibuffer hooks, which need to get | |
491 | ;; restored before falling back. | |
492 | (orig-minibuffer-setup-hook minibuffer-setup-hook) | |
488 | ;; Need to save a copy of this since activating the | |
489 | ;; minibuffer once will clear out any temporary minibuffer | |
490 | ;; hooks, which need to get restored before falling back so | |
491 | ;; that they will trigger again when the fallback function | |
492 | ;; uses the minibuffer. We make a copy in case the original | |
493 | ;; list gets modified in place. | |
494 | (orig-minibuffer-setup-hook (cl-copy-list minibuffer-setup-hook)) | |
493 | 495 | ;; Need just the string part of INITIAL-INPUT |
494 | 496 | (initial-input-string |
495 | 497 | (cond |
524 | 526 | (condition-case sig |
525 | 527 | (progn |
526 | 528 | ;; Check a bunch of fallback conditions |
527 | (when inherit-input-method | |
529 | (when (and inherit-input-method current-input-method) | |
528 | 530 | (signal 'ido-cr+-fallback |
529 | '("ido cannot handle non-nil INHERIT-INPUT-METHOD"))) | |
530 | (when (bound-and-true-p completion-extra-properties) | |
531 | (signal 'ido-cr+-fallback | |
532 | '("ido cannot handle non-nil `completion-extra-properties'"))) | |
531 | '("ido cannot handle alternate input methods"))) | |
533 | 532 | |
534 | 533 | ;; Check for black/white-listed collection function |
535 | 534 | (when (functionp collection) |
692 | 691 | ;; Finally ready to do actual ido completion |
693 | 692 | (prog1 |
694 | 693 | (let ((ido-cr+-minibuffer-depth (1+ (minibuffer-depth))) |
695 | ;; Initialize dynamic update vars | |
696 | (ido-cr+-previous-dynamic-update-texts | |
697 | (list initial-input-string)) | |
698 | 694 | (ido-cr+-dynamic-update-timer nil) |
699 | 695 | (ido-cr+-exhibit-pending t) |
700 | ;; Reset these for the next call to ido-cr+ | |
701 | (ido-cr+-no-default-action 'prepend-empty-string) | |
696 | ;; Reset this for recursive calls to ido-cr+ | |
702 | 697 | (ido-cr+-assume-static-collection nil)) |
703 | 698 | (unwind-protect |
704 | 699 | (ido-completing-read |
717 | 712 | (ido-cr+-fallback |
718 | 713 | (let (;; Reset `minibuffer-setup-hook' to original value |
719 | 714 | (minibuffer-setup-hook orig-minibuffer-setup-hook) |
720 | ;; Reset these for the next call to ido-cr+ | |
721 | (ido-cr+-no-default-action 'prepend-empty-string) | |
715 | ;; Reset this for recursive calls to ido-cr+ | |
722 | 716 | (ido-cr+-assume-static-collection nil)) |
723 | 717 | (ido-cr+--explain-fallback sig) |
724 | 718 | (apply ido-cr+-fallback-function ido-cr+-orig-completing-read-args)))))) |
728 | 722 | "This advice allows ido-cr+ to completely replace `ido-completing-read'. |
729 | 723 | |
730 | 724 | See the varaible `ido-cr+-replace-completely' for more information." |
731 | ;; If this advice is autoloaded, then we need to force loading of | |
732 | ;; the rest of the file so all the variables will be defined. | |
733 | (when (not (featurep 'ido-completing-read+)) | |
734 | (require 'ido-completing-read+)) | |
735 | 725 | (if (or (ido-cr+-active) |
736 | 726 | (not ido-cr+-replace-completely)) |
737 | 727 | ;; ido-cr+ has either already activated or isn't going to |
756 | 746 | #'call-interactively@ido-cr+-record-current-command) |
757 | 747 | |
758 | 748 | ;; Fallback on magic C-f and C-b |
759 | (defun ido-magic-forward-char@ido-cr+-fallback (&rest args) | |
749 | (defun ido-magic-forward-char@ido-cr+-fallback (&rest _args) | |
760 | 750 | "Allow falling back in ido-completing-read+." |
761 | 751 | (when (ido-cr+-active) |
762 | 752 | ;; `ido-context-switch-command' is already let-bound at this |
765 | 755 | (advice-add 'ido-magic-forward-char :before |
766 | 756 | #'ido-magic-forward-char@ido-cr+-fallback) |
767 | 757 | |
768 | (defun ido-magic-backward-char@ido-cr+-fallback (&rest args) | |
758 | (defun ido-magic-backward-char@ido-cr+-fallback (&rest _args) | |
769 | 759 | "Allow falling back in ido-completing-read+." |
770 | 760 | (when (ido-cr+-active) |
771 | 761 | ;; `ido-context-switch-command' is already let-bound at this |
795 | 785 | ;; The current input doesn't exactly match a known option, and... |
796 | 786 | (not (member ido-text ido-cur-list)) |
797 | 787 | ;; The current input doesn't exactly match an option according |
798 | ;; to `try-completion' (or the collection is not dynamic). | |
788 | ;; to `test-completion' (or the collection is not dynamic). | |
799 | 789 | (or (not ido-cr+-dynamic-collection) |
800 | (eq t (try-completion ido-text ido-cr+-dynamic-collection | |
801 | (nth 2 ido-cr+-orig-completing-read-args))))) | |
790 | (test-completion ido-text ido-cr+-dynamic-collection | |
791 | (nth 2 ido-cr+-orig-completing-read-args)))) | |
802 | 792 | (progn |
803 | 793 | (ido-cr+--debug-message |
804 | 794 | "Overriding C-j behavior for require-match: performing completion instead of exiting with current text. (This might still exit with a match if `ido-confirm-unique-completion' is nil)") |
807 | 797 | (advice-add 'ido-select-text :around |
808 | 798 | #'ido-select-text@ido-cr+-fix-require-match) |
809 | 799 | |
810 | (defun ido-tidy@ido-cr+-set-exhibit-pending (&rest args) | |
800 | (defun ido-tidy@ido-cr+-set-exhibit-pending (&rest _args) | |
811 | 801 | (setq ido-cr+-exhibit-pending t)) |
812 | 802 | (advice-add 'ido-tidy :after 'ido-tidy@ido-cr+-set-exhibit-pending) |
813 | 803 | |
814 | (defun ido-exhibit@ido-cr+-clear-exhibit-pending (&rest args) | |
804 | (defun ido-exhibit@ido-cr+-clear-exhibit-pending (&rest _args) | |
815 | 805 | (setq ido-cr+-exhibit-pending nil)) |
816 | 806 | (advice-add 'ido-exhibit :before 'ido-exhibit@ido-cr+-clear-exhibit-pending) |
817 | 807 | |
876 | 866 | (setq need-reverse (not need-reverse)) |
877 | 867 | restriction-matches)) |
878 | 868 | ;; Each run of `ido-set-matches-1' reverses the order, so reverse |
879 | ;; it one more time if it had an odd number of reverses | |
869 | ;; it one more time if it had an odd number of reverses. | |
880 | 870 | finally return |
881 | 871 | (if need-reverse |
882 | 872 | (nreverse filtered-collection) |
888 | 878 | This has no effect unless `ido-cr+-dynamic-collection' is non-nil." |
889 | 879 | (when (and (ido-cr+-active) |
890 | 880 | ido-cr+-dynamic-collection) |
891 | (let* ((ido-text | |
892 | (buffer-substring-no-properties (minibuffer-prompt-end) | |
893 | ido-eoinput)) | |
894 | (predicate (nth 2 ido-cr+-orig-completing-read-args)) | |
895 | (first-match (car ido-matches)) | |
896 | (strings-to-check | |
897 | (cond | |
898 | ;; If no match, then we only check `ido-text' | |
899 | ((null first-match) | |
900 | (list ido-text)) | |
901 | ;; If `ido-text' is a prefix of `first-match', then we | |
902 | ;; only need to check `first-match' | |
903 | ((and first-match | |
904 | (s-prefix? ido-text first-match)) | |
905 | (list first-match)) | |
906 | ;; Otherwise we need to check both | |
907 | (t | |
908 | (list ido-text first-match)))) | |
909 | (new-completions | |
910 | (cl-loop | |
911 | for string in strings-to-check | |
912 | nconc | |
913 | (funcall | |
914 | (or ido-cr+-all-prefix-completions-memoized | |
915 | 'ido-cr+-all-prefix-completions) | |
916 | string ido-cr+-dynamic-collection predicate) | |
917 | into result | |
918 | finally return result))) | |
919 | (when new-completions | |
920 | (setq ido-cur-list (delete-dups new-completions)) | |
921 | (when ido-cr+-active-restrictions | |
922 | (setq ido-cur-list (ido-cr+-apply-restrictions | |
923 | ido-cur-list | |
924 | ido-cr+-active-restrictions))) | |
925 | (when (and first-match (member first-match ido-cur-list)) | |
926 | (setq ido-cur-list (ido-chop ido-cur-list first-match))) | |
927 | (ido-cr+--debug-message | |
928 | "Updated completion candidates for dynamic collection because `ido-text' changed to %S. `ido-cur-list' now has %s elements" | |
929 | ido-text (length ido-cur-list)) | |
930 | ;; Recompute matches with new completions | |
931 | (setq ido-rescan t) | |
932 | (ido-set-matches) | |
933 | ;; Rebuild the completion display unless ido is already planning | |
934 | ;; to do it anyway | |
935 | (unless ido-cr+-exhibit-pending | |
936 | (ido-tidy) | |
937 | (ido-exhibit))))) | |
881 | (let ((orig-ido-cur-list ido-cur-list)) | |
882 | (condition-case-unless-debug err | |
883 | (let* ((ido-text | |
884 | (buffer-substring-no-properties (minibuffer-prompt-end) | |
885 | ido-eoinput)) | |
886 | (predicate (nth 2 ido-cr+-orig-completing-read-args)) | |
887 | (first-match (car ido-matches)) | |
888 | (strings-to-check | |
889 | (cond | |
890 | ;; If no match, then we only check `ido-text' | |
891 | ((null first-match) | |
892 | (list ido-text)) | |
893 | ;; If `ido-text' is a prefix of `first-match', then we | |
894 | ;; only need to check `first-match' | |
895 | ((and first-match | |
896 | (s-prefix? ido-text first-match)) | |
897 | (list first-match)) | |
898 | ;; Otherwise we need to check both | |
899 | (t | |
900 | (list ido-text first-match)))) | |
901 | (new-completions | |
902 | (cl-loop | |
903 | for string in strings-to-check | |
904 | nconc | |
905 | (funcall | |
906 | (or ido-cr+-all-prefix-completions-memoized | |
907 | 'ido-cr+-all-prefix-completions) | |
908 | string ido-cr+-dynamic-collection predicate) | |
909 | into result | |
910 | finally return result))) | |
911 | ;; Put the previous first match back at the front if possible | |
912 | (when (and new-completions | |
913 | first-match | |
914 | (member first-match new-completions)) | |
915 | (setq new-completions | |
916 | (ido-chop new-completions first-match))) | |
917 | (when (not (equal new-completions ido-cur-list)) | |
918 | (when (and (bound-and-true-p flx-ido-mode) | |
919 | (functionp 'flx-ido-reset)) | |
920 | ;; Reset flx-ido since the set of completions has changed | |
921 | (funcall 'flx-ido-reset)) | |
922 | (setq ido-cur-list (delete-dups new-completions)) | |
923 | (when ido-cr+-active-restrictions | |
924 | (setq ido-cur-list (ido-cr+-apply-restrictions | |
925 | ido-cur-list | |
926 | ido-cr+-active-restrictions))) | |
927 | (ido-cr+--debug-message | |
928 | "Updated completion candidates for dynamic collection because `ido-text' changed to %S. `ido-cur-list' now has %s elements" | |
929 | ido-text (length ido-cur-list)) | |
930 | ;; Recompute matches with new completions | |
931 | (setq ido-rescan t) | |
932 | (ido-set-matches) | |
933 | ;; Rebuild the completion display unless ido is already planning | |
934 | ;; to do it anyway | |
935 | (unless ido-cr+-exhibit-pending | |
936 | (ido-tidy) | |
937 | (ido-exhibit)))) | |
938 | (error | |
939 | (display-warning 'ido-cr+ | |
940 | (format | |
941 | "Disabling dynamic update due to error: %S" | |
942 | err)) | |
943 | ;; Reset any variables that might have been modified during | |
944 | ;; the failed update | |
945 | (setq ido-cur-list orig-ido-cur-list) | |
946 | ;; Prevent any further attempts at dynamic updating | |
947 | (setq ido-cr+-dynamic-collection nil))))) | |
938 | 948 | ;; Always cancel an active timer when this function is called. |
939 | 949 | (when ido-cr+-dynamic-update-timer |
940 | 950 | (cancel-timer ido-cr+-dynamic-update-timer) |
1135 | 1145 | (if ido-cr+-auto-update-blacklist |
1136 | 1146 | (let* ((curval ido-cr+-function-blacklist) |
1137 | 1147 | (defval (eval (car (get 'ido-cr+-function-blacklist 'standard-value)))) |
1138 | (new-entries (cl-set-difference curval defval :test #'equal))) | |
1148 | (new-entries (cl-set-difference defval curval :test #'equal))) | |
1139 | 1149 | (if new-entries |
1140 | 1150 | (if (eq ido-cr+-auto-update-blacklist 'notify) |
1141 | 1151 | (display-warning 'ido-completing-read+ "There are %s new blacklist entries available. Use `M-x ido-cr+-update-blacklist' to install them. (See `ido-cr+-auto-update-blacklist' for more information.)") |
3 | 3 | |
4 | 4 | ;; Author: Ryan C. Thompson |
5 | 5 | ;; URL: https://github.com/DarwinAwardWinner/ido-ubiquitous |
6 | ;; Version: 4.5 | |
6 | ;; Version: 4.7 | |
7 | 7 | ;; Created: 2011-09-01 |
8 | 8 | ;; Keywords: convenience, completion, ido |
9 | 9 | ;; EmacsWiki: InteractivelyDoThings |
10 | ;; Package-Requires: ((emacs "24.1") (ido-completing-read+ "4.5") (cl-lib "0.5")) | |
10 | ;; Package-Requires: ((ido-completing-read+ "4.7") (cl-lib "0.5")) | |
11 | 11 | ;; Filename: ido-ubiquitous.el |
12 | 12 | |
13 | 13 | ;; This file is NOT part of GNU Emacs. |
38 | 38 | ;; |
39 | 39 | ;;; Code: |
40 | 40 | |
41 | (defconst ido-ubiquitous-version "4.5" | |
41 | (defconst ido-ubiquitous-version "4.7" | |
42 | 42 | "Currently running version of ido-ubiquitous. |
43 | 43 | |
44 | 44 | Note that when you update ido-ubiquitous, this variable may not |
0 | 0 | ;;; -*- lexical-binding: t -*- |
1 | 1 | |
2 | (require 'undercover) | |
3 | (undercover "*.el" | |
4 | (:exclude "test-*.el")) | |
5 | ||
2 | 6 | (require 'ido) |
7 | (require 'flx-ido) | |
8 | (require 'minibuf-eldef) | |
3 | 9 | (require 'ido-completing-read+) |
4 | 10 | (require 'buttercup) |
5 | 11 | (require 'cl-lib) |
113 | 119 | ;; test, saving the previous values for later restoration. |
114 | 120 | (before-each |
115 | 121 | (shadow-vars |
116 | ((ido-mode t) | |
117 | (ido-ubiquitous-mode t) | |
118 | ido-cr+-debug-mode | |
119 | ido-cr+-auto-update-blacklist | |
120 | ido-cr+-fallback-function | |
121 | ido-cr+-max-items | |
122 | ido-cr+-function-blacklist | |
123 | ido-cr+-function-whitelist | |
124 | ido-cr+-nil-def-alternate-behavior-list | |
125 | ido-cr+-replace-completely | |
126 | ido-confirm-unique-completion | |
127 | ido-enable-flex-matching))) | |
122 | ((ido-mode t) | |
123 | (ido-ubiquitous-mode t) | |
124 | (ido-cr+-debug-mode t) | |
125 | ido-cr+-auto-update-blacklist | |
126 | ido-cr+-fallback-function | |
127 | ido-cr+-max-items | |
128 | ido-cr+-function-blacklist | |
129 | ido-cr+-function-whitelist | |
130 | ido-cr+-nil-def-alternate-behavior-list | |
131 | ido-cr+-replace-completely | |
132 | ido-confirm-unique-completion | |
133 | ido-enable-flex-matching | |
134 | ido-enable-dot-prefix | |
135 | flx-ido-mode | |
136 | (minibuffer-electric-default-mode t))) | |
137 | ||
138 | ;; Suppress all messages during tests | |
139 | (spy-on 'message)) | |
128 | 140 | |
129 | 141 | ;; Restore the saved values after each test |
130 | 142 | (after-each |
137 | 149 | (with-simulated-input "g RET" |
138 | 150 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green"))) |
139 | 151 | :to-equal "green")) |
152 | ||
140 | 153 | (it "should complete with the first match when multiple matches are available" |
141 | 154 | (expect |
142 | 155 | (with-simulated-input "b RET" |
143 | 156 | (ido-completing-read+ "Prompt: " '("brown" "blue" "yellow" "green"))) |
144 | 157 | :to-equal "brown")) |
158 | ||
145 | 159 | (it "should allow <left> and <right> to cycle completions, with wrap-around" |
146 | 160 | (expect |
147 | 161 | (with-simulated-input "b <right> <right> <right> <right> <left> RET" |
169 | 183 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil t)) |
170 | 184 | :to-equal "")) |
171 | 185 | |
172 | ;; Verify that DEF works, whether or not it is an element of | |
173 | ;; COLLECTION | |
174 | 186 | (it "should accept all the same forms of DEF as `completing-read-default'" |
187 | ;; DEF in COLLECTION | |
175 | 188 | (expect |
176 | 189 | (with-simulated-input "RET" |
177 | 190 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil nil nil "green")) |
178 | 191 | :to-equal "green") |
192 | ;; Same, with REQUIRE-MATCH | |
179 | 193 | (expect |
180 | 194 | (with-simulated-input "RET" |
181 | 195 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil t nil nil "green")) |
182 | 196 | :to-equal "green") |
197 | ;; DEF not in COLLECTION | |
183 | 198 | (expect |
184 | 199 | (with-simulated-input "RET" |
185 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "brown") nil nil nil nil "brown")) | |
200 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil nil nil "brown")) | |
186 | 201 | :to-equal "brown") |
202 | ;; Same, with REQUIRE-MATCH | |
187 | 203 | (expect |
188 | 204 | (with-simulated-input "RET" |
189 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "brown") nil t nil nil "brown")) | |
205 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil t nil nil "brown")) | |
190 | 206 | :to-equal "brown") |
207 | ;; List DEF, partially in COLLECTION | |
191 | 208 | (expect |
192 | 209 | (with-simulated-input "RET" |
193 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "brown") nil t nil nil '("brown" "green"))) | |
210 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil t nil nil '("brown" "green"))) | |
194 | 211 | :to-equal "brown")) |
195 | 212 | |
196 | ;; Verify that INITIAL-INPUT works | |
197 | 213 | (it "should work with INITIAL-INPUT" |
198 | 214 | (expect |
199 | 215 | (with-simulated-input "RET" |
200 | 216 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil "gr")) |
201 | 217 | :to-equal "green")) |
202 | 218 | |
203 | ;; Verify that INITIAL-INPUT and DEF don't interfere with each other | |
219 | (it "should properly handle a cons INITIAL-INPUT" | |
220 | (expect | |
221 | (with-simulated-input "ee RET" | |
222 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil (cons "gr" 2))) | |
223 | :to-equal "green")) | |
224 | ||
204 | 225 | (it "should properly handle both INITIAL-INPUT and DEF at the same time" |
205 | 226 | (expect |
206 | 227 | (with-simulated-input "RET" |
211 | 232 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil "gr" nil "blue")) |
212 | 233 | :to-equal "blue")) |
213 | 234 | |
214 | ;; Verify that ido-cr+ works on function collections | |
215 | 235 | (it "should work when COLLECTION is a function" |
216 | 236 | (expect |
217 | 237 | (with-simulated-input "g RET" |
218 | 238 | (ido-completing-read+ "Prompt: " (collection-as-function '("blue" "yellow" "green")))) |
219 | 239 | :to-equal "green")) |
220 | 240 | |
241 | (it "should fall back when COLLECTION is empty" | |
242 | (spy-on 'ido-completing-read :and-call-through) | |
243 | (expect | |
244 | (with-simulated-input "g RET" | |
245 | (ido-completing-read+ "Prompt: " nil)) | |
246 | :to-equal "g") | |
247 | (expect 'ido-completing-read :not :to-have-been-called)) | |
248 | ||
249 | (it "should replace `ido-completing-read' when `ido-cr+-replace-completely' is non-nil" | |
250 | (customize-set-variable 'ido-cr+-replace-completely t) | |
251 | (spy-on 'ido-completing-read+ :and-call-through) | |
252 | (expect | |
253 | (with-simulated-input "g RET" | |
254 | (ido-completing-read "Prompt: " '("blue" "yellow" "green"))) | |
255 | :to-equal "green") | |
256 | (expect 'ido-completing-read+ :to-have-been-called)) | |
257 | ||
221 | 258 | (describe "when `ido-cr+-max-items' is set" |
222 | 259 | (it "should not trigger a fallback for small collections" |
223 | 260 | (expect |
224 | 261 | (with-simulated-input "g RET" |
225 | 262 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green"))) |
226 | 263 | :to-equal "green")) |
264 | ||
227 | 265 | (it "should trigger a fallback for large collections" |
228 | 266 | (expect |
229 | 267 | ;; With max-items negative, all collections are considered "too |
250 | 288 | "Prompt: " |
251 | 289 | '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t nil nil "yellow")) |
252 | 290 | :to-throw)) |
291 | ||
253 | 292 | (it "shouldn't allow C-j to select an ambiguous match" |
254 | 293 | (expect |
255 | 294 | (with-simulated-input "b C-j C-j C-j" |
265 | 304 | "Prompt: " |
266 | 305 | '("bluebird" "blues" "bluegrass" "blueberry" "yellow" "green") nil t)) |
267 | 306 | :to-throw)) |
307 | ||
268 | 308 | (it "should allow exiting with an unambiguous match" |
269 | 309 | (expect |
270 | 310 | (with-simulated-input "b C-j b C-j e C-j C-j" |
280 | 320 | "Prompt: " |
281 | 321 | '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)) |
282 | 322 | :to-equal "bluegrass")) |
323 | ||
283 | 324 | (it "should require an extra C-j to exit when `ido-confirm-unique-completion' is non-nil" |
284 | 325 | (setq ido-confirm-unique-completion t) |
285 | 326 | ;; Now the first "C-j" should complete to "bluegrass" but should |
310 | 351 | '("bluebird" "blues" "bluegrass" "blueberry" "yellow ""green") nil t)) |
311 | 352 | :to-equal "b"))) |
312 | 353 | |
354 | (describe "when INHERIT-INPUT-METHOD is non-nil" | |
355 | ||
356 | (before-each | |
357 | (spy-on 'ido-completing-read :and-call-through)) | |
358 | ||
359 | (it "should not fall back if `current-input-method' is nil" | |
360 | (expect | |
361 | (let ((current-input-method nil)) | |
362 | (with-simulated-input "g RET" | |
363 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil nil nil nil t)) | |
364 | :to-equal "green")) | |
365 | (expect 'ido-completing-read :to-have-been-called)) | |
366 | ||
367 | (it "should fall back if `current-input-method' is non-nil" | |
368 | (expect | |
369 | (let ((current-input-method 'ucs)) | |
370 | (with-simulated-input "g RET" | |
371 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green") nil nil nil nil nil t)) | |
372 | :to-equal "green")) | |
373 | (expect 'ido-completing-read :not :to-have-been-called))) | |
374 | ||
313 | 375 | (describe "with manual fallback shortcuts" |
314 | 376 | (it "should not fall back when C-b or C-f is used in the middle of the input" |
315 | 377 | (expect |
317 | 379 | (with-simulated-input "g C-b C-f RET" |
318 | 380 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green"))) |
319 | 381 | :to-equal "green")) |
382 | ||
320 | 383 | (it "should fall back on C-f at end of input" |
321 | 384 | (expect |
322 | 385 | ;; C-f at end of input should fall back |
323 | 386 | (with-simulated-input "g C-f RET" |
324 | 387 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green"))) |
325 | 388 | :to-equal "g")) |
389 | ||
326 | 390 | (it "should not fall back from repeated C-b that hits the start of input" |
327 | 391 | (expect |
328 | 392 | ;; Repeated C-b should not fall back |
329 | 393 | (with-simulated-input "g C-b C-b C-b C-b RET" |
330 | 394 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "green"))) |
331 | 395 | :to-equal "green")) |
396 | ||
332 | 397 | (it "should fall back on C-b at beginning of input (if previous action was not C-b)" |
333 | 398 | (expect |
334 | 399 | ;; C-b at beginning of line should fall back (if previous action |
342 | 407 | ;; for more information on this bug. |
343 | 408 | (before-each |
344 | 409 | (setq ido-enable-dot-prefix t)) |
410 | ||
345 | 411 | (it "should not throw an error when \"\" is in the collection" |
346 | 412 | (expect |
347 | 413 | (with-simulated-input "RET" |
391 | 457 | "hello-world") |
392 | 458 | (expect 'ido-cr+-update-dynamic-collection |
393 | 459 | :to-have-been-called)) |
460 | ||
394 | 461 | (it "should do a dynamic update when pressing TAB" |
395 | 462 | (expect |
396 | 463 | (with-simulated-input "h TAB -ld RET" |
399 | 466 | "hello-world") |
400 | 467 | (expect 'ido-cr+-update-dynamic-collection |
401 | 468 | :to-have-been-called)) |
469 | ||
402 | 470 | (it "should do a dynamic update when idle" |
403 | 471 | (expect |
404 | 472 | (with-simulated-input |
410 | 478 | "hello-world") |
411 | 479 | (expect 'ido-cr+-update-dynamic-collection |
412 | 480 | :to-have-been-called)) |
481 | ||
413 | 482 | (it "should do a dynamic update when there is only one match remaining" |
414 | 483 | (expect |
415 | 484 | (with-simulated-input "hell-ld RET" |
418 | 487 | "hello-world") |
419 | 488 | (expect 'ido-cr+-update-dynamic-collection |
420 | 489 | :to-have-been-called)) |
490 | ||
421 | 491 | (it "should not exit with a unique match if new matches are dynamically added" |
422 | 492 | (expect |
423 | 493 | (with-simulated-input '("hell TAB -ld RET") |
426 | 496 | "hello-world") |
427 | 497 | (expect 'ido-cr+-update-dynamic-collection |
428 | 498 | :to-have-been-called)) |
499 | ||
429 | 500 | (it "should exit with a match that is still unique after dynamic updating" |
430 | 501 | (expect |
431 | 502 | (with-simulated-input '("helic TAB") |
434 | 505 | "helicopter") |
435 | 506 | (expect 'ido-cr+-update-dynamic-collection |
436 | 507 | :to-have-been-called)) |
508 | ||
509 | (it "should suppress errors raised by dynamic completion updates" | |
510 | (let ((collection | |
511 | (completion-table-dynamic | |
512 | (lambda (text) | |
513 | (cond | |
514 | ((equal text "") | |
515 | '("hello" "goodbye" "helicopter" "helium" "goodness" "goodwill")) | |
516 | (t (error "This collection throws an error on a nonempty prefix")))))) | |
517 | ;; The test framework uses the debugger to catch error | |
518 | ;; stack traces, but we want to run this code as if it | |
519 | ;; was not being debugged. | |
520 | (debug-on-error nil)) | |
521 | (expect | |
522 | (with-simulated-input '("hell TAB RET") | |
523 | (ido-completing-read+ "Say something: " collection)) | |
524 | :to-equal | |
525 | "hello"))) | |
526 | ||
437 | 527 | (it "should respect `ido-restrict-to-matches' when doing dynamic updates" |
528 | (assume (version<= "25" emacs-version)) | |
438 | 529 | (let ((collection |
439 | 530 | (list "aaa-ddd-ggg" "aaa-eee-ggg" "aaa-fff-ggg" |
440 | 531 | "bbb-ddd-ggg" "bbb-eee-ggg" "bbb-fff-ggg" |
452 | 543 | (list (cons nil "bbb") |
453 | 544 | (cons nil "eee"))) |
454 | 545 | :to-equal '("bbb-eee-ggg" "bbb-eee-hhh" "bbb-eee-iii")) |
455 | ||
456 | 546 | ;; First verify it without a dynamic collection |
457 | 547 | (expect |
458 | 548 | (with-simulated-input "eee C-SPC bbb C-SPC ggg RET" |
459 | 549 | (ido-completing-read+ |
460 | 550 | "Pick: " collection nil t nil nil (car collection))) |
461 | 551 | :to-equal "bbb-eee-ggg") |
552 | (expect | |
553 | (with-simulated-input "eee C-SPC aaa C-u C-SPC ccc C-u C-SPC ggg RET" | |
554 | (ido-completing-read+ | |
555 | "Pick: " collection nil t nil nil (car collection))) | |
556 | :to-equal "bbb-eee-ggg") | |
462 | 557 | ;; Now test the same with a dynamic collection |
463 | 558 | (expect |
464 | 559 | (with-simulated-input "eee C-SPC bbb C-SPC ggg RET" |
465 | 560 | (ido-completing-read+ |
466 | 561 | "Pick: " (collection-as-function collection) nil t nil nil (car collection))) |
467 | :to-equal "bbb-eee-ggg")))) | |
562 | :to-equal "bbb-eee-ggg") | |
563 | (expect | |
564 | (with-simulated-input "eee C-SPC aaa C-u C-SPC ccc C-u C-SPC ggg RET" | |
565 | (ido-completing-read+ | |
566 | "Pick: " (collection-as-function collection) nil t nil nil (car collection))) | |
567 | :to-equal "bbb-eee-ggg"))) | |
568 | ||
569 | (describe "with flx-ido-mode" | |
570 | (before-each | |
571 | (flx-ido-mode 1) | |
572 | (flx-ido-reset)) | |
573 | ||
574 | (it "should allow selection of dynamically-added completions" | |
575 | (expect | |
576 | (with-simulated-input "hello-w RET" | |
577 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
578 | :to-equal "hello-world") | |
579 | (expect 'ido-cr+-update-dynamic-collection | |
580 | :to-have-been-called)) | |
581 | ||
582 | (it "should allow ido flex-matching of dynamically-added completions" | |
583 | (expect | |
584 | (with-simulated-input "hello-ld RET" | |
585 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
586 | :to-equal | |
587 | "hello-world") | |
588 | (expect 'ido-cr+-update-dynamic-collection | |
589 | :to-have-been-called)) | |
590 | ||
591 | (it "should do a dynamic update when pressing TAB" | |
592 | (expect | |
593 | (with-simulated-input "h TAB -ld RET" | |
594 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
595 | :to-equal | |
596 | "hello-world") | |
597 | (expect 'ido-cr+-update-dynamic-collection | |
598 | :to-have-been-called)) | |
599 | ||
600 | (it "should do a dynamic update when idle" | |
601 | (expect | |
602 | (with-simulated-input | |
603 | '("h" | |
604 | (wsi-simulate-idle-time (1+ ido-cr+-dynamic-update-idle-time)) | |
605 | "-ld RET") | |
606 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
607 | :to-equal | |
608 | "hello-world") | |
609 | (expect 'ido-cr+-update-dynamic-collection | |
610 | :to-have-been-called)) | |
611 | ||
612 | (it "should do a dynamic update when there is only one match remaining" | |
613 | (expect | |
614 | (with-simulated-input "hell-ld RET" | |
615 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
616 | :to-equal | |
617 | "hello-world") | |
618 | (expect 'ido-cr+-update-dynamic-collection | |
619 | :to-have-been-called)) | |
620 | ||
621 | (it "should not exit with a unique match if new matches are dynamically added" | |
622 | (expect | |
623 | (with-simulated-input '("hell TAB -ld RET") | |
624 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
625 | :to-equal | |
626 | "hello-world") | |
627 | (expect 'ido-cr+-update-dynamic-collection | |
628 | :to-have-been-called)) | |
629 | ||
630 | (it "should exit with a match that is still unique after dynamic updating" | |
631 | (expect | |
632 | (with-simulated-input '("helic TAB") | |
633 | (ido-completing-read+ "Say something: " my-dynamic-collection)) | |
634 | :to-equal | |
635 | "helicopter") | |
636 | (expect 'ido-cr+-update-dynamic-collection | |
637 | :to-have-been-called)) | |
638 | ||
639 | (it "should respect `ido-restrict-to-matches' when doing dynamic updates" | |
640 | (let ((collection | |
641 | (list "aaa-ddd-ggg" "aaa-eee-ggg" "aaa-fff-ggg" | |
642 | "bbb-ddd-ggg" "bbb-eee-ggg" "bbb-fff-ggg" | |
643 | "ccc-ddd-ggg" "ccc-eee-ggg" "ccc-fff-ggg" | |
644 | "aaa-ddd-hhh" "aaa-eee-hhh" "aaa-fff-hhh" | |
645 | "bbb-ddd-hhh" "bbb-eee-hhh" "bbb-fff-hhh" | |
646 | "ccc-ddd-hhh" "ccc-eee-hhh" "ccc-fff-hhh" | |
647 | "aaa-ddd-iii" "aaa-eee-iii" "aaa-fff-iii" | |
648 | "bbb-ddd-iii" "bbb-eee-iii" "bbb-fff-iii" | |
649 | "ccc-ddd-iii" "ccc-eee-iii" "ccc-fff-iii"))) | |
650 | ;; Test the internal function | |
651 | (expect | |
652 | (ido-cr+-apply-restrictions | |
653 | collection | |
654 | (list (cons nil "bbb") | |
655 | (cons nil "eee"))) | |
656 | :to-equal '("bbb-eee-ggg" "bbb-eee-hhh" "bbb-eee-iii")) | |
657 | ||
658 | ;; First verify it without a dynamic collection | |
659 | (expect | |
660 | (with-simulated-input "eee C-SPC bbb C-SPC ggg RET" | |
661 | (ido-completing-read+ | |
662 | "Pick: " collection nil t nil nil (car collection))) | |
663 | :to-equal "bbb-eee-ggg") | |
664 | ;; Now test the same with a dynamic collection | |
665 | (expect | |
666 | (with-simulated-input "eee C-SPC bbb C-SPC ggg RET" | |
667 | (ido-completing-read+ | |
668 | "Pick: " (collection-as-function collection) nil t nil nil (car collection))) | |
669 | :to-equal "bbb-eee-ggg"))))) | |
468 | 670 | |
469 | 671 | (describe "with unusual inputs" |
470 | 672 | (it "should accept a COLLECTION of symbols" |
472 | 674 | (with-simulated-input "g RET" |
473 | 675 | (ido-completing-read+ "Prompt: " '(blue yellow green))) |
474 | 676 | :to-equal "green")) |
677 | ||
475 | 678 | (it "should accept a mix of strings and symbols in COLLECTION" |
476 | 679 | (expect |
477 | 680 | (with-simulated-input "g RET" |
478 | 681 | (ido-completing-read+ "Prompt: " '(blue "yellow" green))) |
479 | 682 | :to-equal "green")) |
683 | ||
480 | 684 | (it "should accept symbols in DEF" |
481 | 685 | (expect |
482 | 686 | (with-simulated-input "RET" |
483 | 687 | (ido-completing-read+ "Prompt: " '("blue" "yellow" "brown") nil t nil nil '(brown "green"))) |
484 | 688 | :to-equal "brown")) |
689 | ||
485 | 690 | (it "should accept an alist COLLECTION" |
486 | 691 | (expect |
487 | 692 | (with-simulated-input "RET" |
492 | 697 | (green . green-value)) |
493 | 698 | nil nil nil nil "green")) |
494 | 699 | :to-equal "green")) |
700 | ||
495 | 701 | (it "should accept a hash table COLLECTION" |
496 | 702 | (expect |
497 | 703 | (with-simulated-input "RET" |
501 | 707 | (puthash 'green 'green-value collection) |
502 | 708 | (ido-completing-read+ "Prompt: " collection nil nil nil nil "green"))) |
503 | 709 | :to-equal "green")) |
710 | ||
504 | 711 | (it "should accept an obarray COLLECTION" |
505 | 712 | (expect |
506 | 713 | (with-simulated-input "forward-char RET" |
527 | 734 | (with-simulated-input "g RET" |
528 | 735 | (command-execute 'test-command))) |
529 | 736 | :to-equal "green")) |
737 | ||
530 | 738 | (it "should disable itself properly" |
531 | 739 | (expect |
532 | 740 | (progn |
550 | 758 | (funcall 'blacklisted-function)) |
551 | 759 | (symbol-function 'blacklisted-collection) |
552 | 760 | (collection-as-function '("blue" "yellow" "green")))) |
761 | ||
553 | 762 | (after-all |
554 | 763 | (setf (symbol-function 'blacklisted-command) nil |
555 | 764 | (symbol-function 'blacklisted-function) nil |
556 | 765 | (symbol-function 'cmd-that-calls-blacklisted-function) nil |
557 | 766 | (symbol-function 'blacklisted-collection) nil)) |
558 | 767 | ;; First verify that they work normally before blacklisting them |
559 | (describe "when the blacklist is empty" | |
768 | (describe "when the specified functions are not blacklisted" | |
769 | ||
560 | 770 | (it "should not affect a non-blacklisted command" |
561 | 771 | (expect |
562 | 772 | (with-simulated-input "g RET" |
563 | 773 | (call-interactively 'blacklisted-command)) |
564 | 774 | :to-equal "green")) |
775 | ||
565 | 776 | (it "should not affect a non-blacklisted function" |
566 | 777 | (expect |
567 | 778 | (with-simulated-input "g RET" |
568 | 779 | (call-interactively 'cmd-that-calls-blacklisted-function)) |
569 | 780 | :to-equal "green")) |
781 | ||
570 | 782 | (it "should not affect a non-blacklisted collection" |
571 | 783 | (expect |
572 | 784 | (with-simulated-input "g RET" |
580 | 792 | blacklisted-function |
581 | 793 | blacklisted-collection) |
582 | 794 | ido-cr+-function-blacklist))) |
795 | ||
583 | 796 | (it "should prevent ido in a blacklisted command" |
584 | 797 | (expect |
585 | 798 | (with-simulated-input "g RET" |
586 | 799 | (call-interactively 'blacklisted-command)) |
587 | 800 | :to-equal "g")) |
801 | ||
588 | 802 | (it "should prevent ido in a blacklisted function" |
589 | 803 | (expect |
590 | 804 | (with-simulated-input "g RET" |
591 | 805 | (call-interactively 'cmd-that-calls-blacklisted-function)) |
592 | 806 | :to-equal "g")) |
807 | ||
593 | 808 | (it "should prevent ido with a blacklisted collection" |
594 | 809 | (expect |
595 | 810 | (with-simulated-input "g RET" |
596 | 811 | (ido-completing-read+ "Prompt: " 'blacklisted-collection)) |
597 | :to-equal "g")))) | |
812 | :to-equal "g"))) | |
813 | ||
814 | (describe "when updating ido-cr+" | |
815 | ||
816 | (before-each | |
817 | (spy-on 'ido-cr+-update-blacklist :and-call-through)) | |
818 | ||
819 | (it "should update the blacklist when `ido-cr+-auto-update-blacklist' is t" | |
820 | (assume ido-cr+-function-blacklist) | |
821 | (let ((orig-blacklist ido-cr+-function-blacklist)) | |
822 | (customize-set-variable 'ido-cr+-auto-update-blacklist t) | |
823 | (customize-set-variable 'ido-cr+-function-blacklist nil) | |
824 | (ido-cr+-maybe-update-blacklist) | |
825 | (expect 'ido-cr+-update-blacklist :to-have-been-called) | |
826 | (expect ido-cr+-function-blacklist :to-have-same-items-as orig-blacklist))) | |
827 | (it "should not update the blacklist when `ido-cr+-auto-update-blacklist' is nil" | |
828 | (assume ido-cr+-function-blacklist) | |
829 | (let ((orig-blacklist ido-cr+-function-blacklist)) | |
830 | (customize-set-variable 'ido-cr+-auto-update-blacklist nil) | |
831 | (customize-set-variable 'ido-cr+-function-blacklist nil) | |
832 | (ido-cr+-maybe-update-blacklist) | |
833 | (expect 'ido-cr+-update-blacklist :not :to-have-been-called) | |
834 | (expect ido-cr+-function-blacklist :to-have-same-items-as nil))) | |
835 | ||
836 | (it "should notify about blacklist updates when `ido-cr+-auto-update-blacklist' is `notify'" | |
837 | (assume ido-cr+-function-blacklist) | |
838 | (spy-on 'display-warning) | |
839 | (let ((orig-blacklist ido-cr+-function-blacklist)) | |
840 | (customize-set-variable 'ido-cr+-auto-update-blacklist 'notify) | |
841 | (customize-set-variable 'ido-cr+-function-blacklist nil) | |
842 | (ido-cr+-maybe-update-blacklist) | |
843 | (expect 'ido-cr+-update-blacklist :not :to-have-been-called) | |
844 | (expect 'display-warning :to-have-been-called) | |
845 | (expect ido-cr+-function-blacklist :to-have-same-items-as nil))))) | |
598 | 846 | |
599 | 847 | (describe "with `ido-cr+-function-whitelist'" |
600 | 848 | (before-all |
614 | 862 | (symbol-function 'whitelisted-collection) |
615 | 863 | (lambda (string pred action) |
616 | 864 | (complete-with-action action '("blue" "yellow" "green") string pred)))) |
865 | ||
617 | 866 | (after-all |
618 | 867 | (setf (symbol-function 'whitelisted-command) nil |
619 | 868 | (symbol-function 'whitelisted-function) nil |
620 | 869 | (symbol-function 'cmd-that-calls-whitelisted-function) nil |
621 | 870 | (symbol-function 'whitelisted-collection) nil)) |
871 | ||
622 | 872 | (describe "when the whitelist is inactive (i.e. everything is whitelisted)" |
623 | 873 | (before-each |
624 | 874 | (setq ido-cr+-function-whitelist nil)) |
875 | ||
625 | 876 | (it "should enable ido in a command" |
626 | 877 | (expect |
627 | 878 | (with-simulated-input "g RET" |
628 | 879 | (call-interactively 'whitelisted-command)) |
629 | 880 | :to-equal "green")) |
881 | ||
630 | 882 | (it "should enable ido in a function" |
631 | 883 | (expect |
632 | 884 | (with-simulated-input "g RET" |
633 | 885 | (call-interactively 'cmd-that-calls-whitelisted-function)) |
634 | 886 | :to-equal "green")) |
887 | ||
635 | 888 | (it "should enable ido for a collection" |
636 | 889 | (expect |
637 | 890 | (with-simulated-input "g RET" |
638 | 891 | (ido-completing-read+ "Prompt: " 'whitelisted-collection)) |
639 | 892 | :to-equal "green"))) |
893 | ||
640 | 894 | (describe "when the specified functions are whitelisted" |
641 | 895 | (before-each |
642 | 896 | (setq ido-cr+-function-whitelist |
644 | 898 | whitelisted-function |
645 | 899 | whitelisted-collection) |
646 | 900 | ido-cr+-function-whitelist))) |
901 | ||
647 | 902 | (it "should enable ido in a whitelisted command" |
648 | 903 | (expect |
649 | 904 | (with-simulated-input "g RET" |
650 | 905 | (call-interactively 'whitelisted-command)) |
651 | 906 | :to-equal "green")) |
907 | ||
652 | 908 | (it "should enable ido in a whitelisted function" |
653 | 909 | (expect |
654 | 910 | (with-simulated-input "g RET" |
655 | 911 | (call-interactively 'cmd-that-calls-whitelisted-function)) |
656 | 912 | :to-equal "green")) |
913 | ||
657 | 914 | (it "should enable ido for a whitelisted collection" |
658 | 915 | (expect |
659 | 916 | (with-simulated-input "g RET" |
660 | 917 | (ido-completing-read+ "Prompt: " 'whitelisted-collection)) |
661 | 918 | :to-equal "green"))) |
919 | ||
662 | 920 | (describe "when the whitelist is active but empty (i.e. nothing whitelisted)" |
663 | 921 | (before-each |
664 | 922 | (setq ido-cr+-function-whitelist (list nil))) |
923 | ||
665 | 924 | (it "should prevent ido in a command" |
666 | 925 | (expect |
667 | 926 | (with-simulated-input "g RET" |
668 | 927 | (call-interactively 'whitelisted-command)) |
669 | 928 | :to-equal "g")) |
929 | ||
670 | 930 | (it "should prevent ido in a function" |
671 | 931 | (expect |
672 | 932 | (with-simulated-input "g RET" |
673 | 933 | (call-interactively 'cmd-that-calls-whitelisted-function)) |
674 | 934 | :to-equal "g")) |
935 | ||
675 | 936 | (it "should prevent ido for a collection" |
676 | 937 | (expect |
677 | 938 | (with-simulated-input "g RET" |
696 | 957 | (symbol-function 'def-nil-collection) |
697 | 958 | (lambda (string pred action) |
698 | 959 | (complete-with-action action '("blue" "yellow" "green") string pred)))) |
960 | ||
699 | 961 | (after-all |
700 | 962 | (setf (symbol-function 'def-nil-command) nil |
701 | 963 | (symbol-function 'def-nil-function) nil |
711 | 973 | (with-simulated-input "RET" |
712 | 974 | (call-interactively 'def-nil-command)) |
713 | 975 | :to-equal "")) |
976 | ||
714 | 977 | (it "should use empty string default in a function" |
715 | 978 | (expect |
716 | 979 | (with-simulated-input "RET" |
717 | 980 | (call-interactively 'cmd-that-calls-def-nil-function)) |
718 | 981 | :to-equal "")) |
982 | ||
719 | 983 | (it "should use empty string default for a collection" |
720 | 984 | (expect |
721 | 985 | (with-simulated-input "RET" |
729 | 993 | def-nil-function |
730 | 994 | def-nil-collection) |
731 | 995 | ido-cr+-nil-def-alternate-behavior-list))) |
996 | ||
732 | 997 | (it "should not use empty string default in a command" |
733 | 998 | (expect |
734 | 999 | (with-simulated-input "RET" |
735 | 1000 | (call-interactively 'def-nil-command)) |
736 | 1001 | :to-equal "blue")) |
1002 | ||
737 | 1003 | (it "should not use empty string default in a function" |
738 | 1004 | (expect |
739 | 1005 | (with-simulated-input "RET" |
740 | 1006 | (call-interactively 'cmd-that-calls-def-nil-function)) |
741 | 1007 | :to-equal "blue")) |
1008 | ||
742 | 1009 | (it "should not use empty string default for a collection" |
743 | 1010 | (expect |
744 | 1011 | (with-simulated-input "RET" |