From 5902a5b83ba0dd060ff4e7fe7dc8e74e4218b1c2 Mon Sep 17 00:00:00 2001 From: brettlangdon Date: Tue, 13 Aug 2013 08:51:43 -0400 Subject: [PATCH] add projectile --- emacs | 5 + emacs.d/elpa/dash-1.5.0/dash-autoloads.el | 18 + emacs.d/elpa/dash-1.5.0/dash-pkg.el | 1 + emacs.d/elpa/dash-1.5.0/dash-pkg.elc | Bin 0 -> 615 bytes emacs.d/elpa/dash-1.5.0/dash.el | 1006 ++++++++++++++++ emacs.d/elpa/dash-1.5.0/dash.elc | Bin 0 -> 32825 bytes emacs.d/elpa/grizzl-0.1.1/grizzl-autoloads.el | 85 ++ emacs.d/elpa/grizzl-0.1.1/grizzl-core.el | 226 ++++ emacs.d/elpa/grizzl-0.1.1/grizzl-core.elc | Bin 0 -> 6324 bytes emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.el | 3 + emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.elc | Bin 0 -> 642 bytes emacs.d/elpa/grizzl-0.1.1/grizzl-read.el | 186 +++ emacs.d/elpa/grizzl-0.1.1/grizzl-read.elc | Bin 0 -> 6168 bytes emacs.d/elpa/grizzl-0.1.1/grizzl.el | 26 + emacs.d/elpa/grizzl-0.1.1/grizzl.elc | Bin 0 -> 650 bytes .../projectile-0.9.2/projectile-autoloads.el | 52 + .../elpa/projectile-0.9.2/projectile-pkg.el | 1 + .../elpa/projectile-0.9.2/projectile-pkg.elc | Bin 0 -> 672 bytes emacs.d/elpa/projectile-0.9.2/projectile.el | 1015 +++++++++++++++++ emacs.d/elpa/projectile-0.9.2/projectile.elc | Bin 0 -> 41745 bytes emacs.d/elpa/s-1.6.1/s-autoloads.el | 18 + emacs.d/elpa/s-1.6.1/s-pkg.el | 1 + emacs.d/elpa/s-1.6.1/s-pkg.elc | Bin 0 -> 623 bytes emacs.d/elpa/s-1.6.1/s.el | 532 +++++++++ emacs.d/elpa/s-1.6.1/s.elc | Bin 0 -> 16209 bytes 25 files changed, 3175 insertions(+) create mode 100644 emacs.d/elpa/dash-1.5.0/dash-autoloads.el create mode 100644 emacs.d/elpa/dash-1.5.0/dash-pkg.el create mode 100644 emacs.d/elpa/dash-1.5.0/dash-pkg.elc create mode 100644 emacs.d/elpa/dash-1.5.0/dash.el create mode 100644 emacs.d/elpa/dash-1.5.0/dash.elc create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-autoloads.el create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-core.el create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-core.elc create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.el create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.elc create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-read.el create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl-read.elc create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl.el create mode 100644 emacs.d/elpa/grizzl-0.1.1/grizzl.elc create mode 100644 emacs.d/elpa/projectile-0.9.2/projectile-autoloads.el create mode 100644 emacs.d/elpa/projectile-0.9.2/projectile-pkg.el create mode 100644 emacs.d/elpa/projectile-0.9.2/projectile-pkg.elc create mode 100644 emacs.d/elpa/projectile-0.9.2/projectile.el create mode 100644 emacs.d/elpa/projectile-0.9.2/projectile.elc create mode 100644 emacs.d/elpa/s-1.6.1/s-autoloads.el create mode 100644 emacs.d/elpa/s-1.6.1/s-pkg.el create mode 100644 emacs.d/elpa/s-1.6.1/s-pkg.elc create mode 100644 emacs.d/elpa/s-1.6.1/s.el create mode 100644 emacs.d/elpa/s-1.6.1/s.elc diff --git a/emacs b/emacs index e3d5ed9..60c5c02 100644 --- a/emacs +++ b/emacs @@ -38,6 +38,11 @@ (require 'flymake-cursor) (add-hook 'find-file-hook 'flymake-find-file-hook) +(require 'projectile) +(setq projectile-completion-system 'grizzl) +(setq projectile-use-native-indexing t) +(setq projectile-enable-caching t) + (elpy-enable) ;call gofmt on the script when saving diff --git a/emacs.d/elpa/dash-1.5.0/dash-autoloads.el b/emacs.d/elpa/dash-1.5.0/dash-autoloads.el new file mode 100644 index 0000000..e7af8c2 --- /dev/null +++ b/emacs.d/elpa/dash-1.5.0/dash-autoloads.el @@ -0,0 +1,18 @@ +;;; dash-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads nil nil ("dash-pkg.el" "dash.el") (21002 9889 395401 +;;;;;; 0)) + +;;;*** + +(provide 'dash-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; dash-autoloads.el ends here diff --git a/emacs.d/elpa/dash-1.5.0/dash-pkg.el b/emacs.d/elpa/dash-1.5.0/dash-pkg.el new file mode 100644 index 0000000..6e14dbe --- /dev/null +++ b/emacs.d/elpa/dash-1.5.0/dash-pkg.el @@ -0,0 +1 @@ +(define-package "dash" "1.5.0" "A modern list library for Emacs" (quote nil)) diff --git a/emacs.d/elpa/dash-1.5.0/dash-pkg.elc b/emacs.d/elpa/dash-1.5.0/dash-pkg.elc new file mode 100644 index 0000000000000000000000000000000000000000..f4530c74e3a6d0876700892109225aca280402ca GIT binary patch literal 615 zcmbu6O-{ow5QV$W1=xAY&yC;A|8EELEL$( zOzq~OYMloZBFz2cldW04{>Km$7=}D>G9H7t_f@hAFDBW(?vF>{4O-+rG&vvb(Fkw^ z91WBbG~pkU?_nHBv|33Ez6rv7Ir)Y_u3AF_*RCjvZiTFrkx7UAjJ1S#h$)763@Yqf aXh}$GK&$YLT9p><1uC*rVlfz{@1ifq7`R0M literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/dash-1.5.0/dash.el b/emacs.d/elpa/dash-1.5.0/dash.el new file mode 100644 index 0000000..1043c23 --- /dev/null +++ b/emacs.d/elpa/dash-1.5.0/dash.el @@ -0,0 +1,1006 @@ +;;; dash.el --- A modern list library for Emacs + +;; Copyright (C) 2012 Magnar Sveen + +;; Author: Magnar Sveen +;; Version: 1.5.0 +;; Keywords: lists + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see . + +;;; Commentary: + +;; A modern list api for Emacs. +;; +;; See documentation on https://github.com/magnars/dash.el#functions + +;;; Code: + +(defmacro !cons (car cdr) + "Destructive: Sets CDR to the cons of CAR and CDR." + `(setq ,cdr (cons ,car ,cdr))) + +(defmacro !cdr (list) + "Destructive: Sets LIST to the cdr of LIST." + `(setq ,list (cdr ,list))) + +(defmacro --each (list &rest body) + "Anaphoric form of `-each'." + (declare (debug t)) + (let ((l (make-symbol "list"))) + `(let ((,l ,list) + (it-index 0)) + (while ,l + (let ((it (car ,l))) + ,@body) + (setq it-index (1+ it-index)) + (!cdr ,l))))) + +(put '--each 'lisp-indent-function 1) + +(defun -each (list fn) + "Calls FN with every item in LIST. Returns nil, used for side-effects only." + (--each list (funcall fn it))) + +(defmacro --each-while (list pred &rest body) + "Anaphoric form of `-each-while'." + (let ((l (make-symbol "list")) + (c (make-symbol "continue"))) + `(let ((,l ,list) + (,c t)) + (while (and ,l ,c) + (let ((it (car ,l))) + (if (not ,pred) (setq ,c nil) ,@body)) + (!cdr ,l))))) + +(put '--each-while 'lisp-indent-function 2) + +(defun -each-while (list pred fn) + "Calls FN with every item in LIST while (PRED item) is non-nil. +Returns nil, used for side-effects only." + (--each-while list (funcall pred it) (funcall fn it))) + +(defmacro --dotimes (num &rest body) + "Repeatedly executes BODY (presumably for side-effects) with `it` bound to integers from 0 through n-1." + `(let ((it 0)) + (while (< it ,num) + ,@body + (setq it (1+ it))))) + +(put '--dotimes 'lisp-indent-function 1) + +(defun -dotimes (num fn) + "Repeatedly calls FN (presumably for side-effects) passing in integers from 0 through n-1." + (--dotimes num (funcall fn it))) + +(defun -map (fn list) + "Returns a new list consisting of the result of applying FN to the items in LIST." + (mapcar fn list)) + +(defmacro --map (form list) + "Anaphoric form of `-map'." + (declare (debug t)) + `(mapcar (lambda (it) ,form) ,list)) + +(defmacro --reduce-from (form initial-value list) + "Anaphoric form of `-reduce-from'." + `(let ((acc ,initial-value)) + (--each ,list (setq acc ,form)) + acc)) + +(defun -reduce-from (fn initial-value list) + "Returns the result of applying FN to INITIAL-VALUE and the +first item in LIST, then applying FN to that result and the 2nd +item, etc. If LIST contains no items, returns INITIAL-VALUE and +FN is not called. + +In the anaphoric form `--reduce-from', the accumulated value is +exposed as `acc`." + (--reduce-from (funcall fn acc it) initial-value list)) + +(defmacro --reduce (form list) + "Anaphoric form of `-reduce'." + (let ((lv (make-symbol "list-value"))) + `(let ((,lv ,list)) + (if ,lv + (--reduce-from ,form (car ,lv) (cdr ,lv)) + (let (acc it) ,form))))) + +(defun -reduce (fn list) + "Returns the result of applying FN to the first 2 items in LIST, +then applying FN to that result and the 3rd item, etc. If LIST +contains no items, FN must accept no arguments as well, and +reduce returns the result of calling FN with no arguments. If +LIST has only 1 item, it is returned and FN is not called. + +In the anaphoric form `--reduce', the accumulated value is +exposed as `acc`." + (if list + (-reduce-from fn (car list) (cdr list)) + (funcall fn))) + +(defun -reduce-r-from (fn initial-value list) + "Replace conses with FN, nil with INITIAL-VALUE and evaluate +the resulting expression. If LIST is empty, INITIAL-VALUE is +returned and FN is not called. + +Note: this function works the same as `-reduce-from' but the +operation associates from right instead of from left." + (if (not list) initial-value + (funcall fn (car list) (-reduce-r-from fn initial-value (cdr list))))) + +(defmacro --reduce-r-from (form initial-value list) + "Anaphoric version of `-reduce-r-from'." + `(-reduce-r-from (lambda (&optional it acc) ,form) ,initial-value ,list)) + +(defun -reduce-r (fn list) + "Replace conses with FN and evaluate the resulting expression. +The final nil is ignored. If LIST contains no items, FN must +accept no arguments as well, and reduce returns the result of +calling FN with no arguments. If LIST has only 1 item, it is +returned and FN is not called. + +The first argument of FN is the new item, the second is the +accumulated value. + +Note: this function works the same as `-reduce' but the operation +associates from right instead of from left." + (cond + ((not list) (funcall fn)) + ((not (cdr list)) (car list)) + (t (funcall fn (car list) (-reduce-r fn (cdr list)))))) + +(defmacro --reduce-r (form list) + "Anaphoric version of `-reduce-r'." + `(-reduce-r (lambda (&optional it acc) ,form) ,list)) + +(defmacro --filter (form list) + "Anaphoric form of `-filter'." + (let ((r (make-symbol "result"))) + `(let (,r) + (--each ,list (when ,form (!cons it ,r))) + (nreverse ,r)))) + +(defun -filter (pred list) + "Returns a new list of the items in LIST for which PRED returns a non-nil value. + +Alias: `-select'" + (--filter (funcall pred it) list)) + +(defalias '-select '-filter) +(defalias '--select '--filter) + +(defmacro --remove (form list) + "Anaphoric form of `-remove'." + (declare (debug t)) + `(--filter (not ,form) ,list)) + +(defun -remove (pred list) + "Returns a new list of the items in LIST for which PRED returns nil. + +Alias: `-reject'" + (--remove (funcall pred it) list)) + +(defalias '-reject '-remove) +(defalias '--reject '--remove) + +(defmacro --keep (form list) + "Anaphoric form of `-keep'." + (let ((r (make-symbol "result")) + (m (make-symbol "mapped"))) + `(let (,r) + (--each ,list (let ((,m ,form)) (when ,m (!cons ,m ,r)))) + (nreverse ,r)))) + +(defun -keep (fn list) + "Returns a new list of the non-nil results of applying FN to the items in LIST." + (--keep (funcall fn it) list)) + +(defmacro --map-when (pred rep list) + "Anaphoric form of `-map-when'." + (let ((r (make-symbol "result"))) + `(let (,r) + (--each ,list (!cons (if ,pred ,rep it) ,r)) + (nreverse ,r)))) + +(defmacro --map-indexed (form list) + "Anaphoric form of `-map-indexed'." + (let ((r (make-symbol "result"))) + `(let (,r) + (--each ,list + (!cons ,form ,r)) + (nreverse ,r)))) + +(defun -map-indexed (fn list) + "Returns a new list consisting of the result of (FN index item) for each item in LIST. + +In the anaphoric form `--map-indexed', the index is exposed as `it-index`." + (--map-indexed (funcall fn it-index it) list)) + +(defun -map-when (pred rep list) + "Returns a new list where the elements in LIST that does not match the PRED function +are unchanged, and where the elements in LIST that do match the PRED function are mapped +through the REP function." + (--map-when (funcall pred it) (funcall rep it) list)) + +(defalias '--replace-where '--map-when) +(defalias '-replace-where '-map-when) + +(defun -flatten (l) + "Takes a nested list L and returns its contents as a single, flat list." + (if (and (listp l) (listp (cdr l))) + (-mapcat '-flatten l) + (list l))) + +(defun -concat (&rest lists) + "Returns a new list with the concatenation of the elements in the supplied LISTS." + (apply 'append lists)) + +(defmacro --mapcat (form list) + "Anaphoric form of `-mapcat'." + (declare (debug t)) + `(apply 'append (--map ,form ,list))) + +(defun -mapcat (fn list) + "Returns the concatenation of the result of mapping FN over LIST. +Thus function FN should return a list." + (--mapcat (funcall fn it) list)) + +(defun -cons* (&rest args) + "Makes a new list from the elements of ARGS. + +The last 2 members of ARGS are used as the final cons of the +result so if the final member of ARGS is not a list the result is +a dotted list." + (let (res) + (--each + args + (cond + ((not res) + (setq res it)) + ((consp res) + (setcdr res (cons (cdr res) it))) + (t + (setq res (cons res it))))) + res)) + +(defmacro --first (form list) + "Anaphoric form of `-first'." + (let ((n (make-symbol "needle"))) + `(let (,n) + (--each-while ,list (not ,n) + (when ,form (setq ,n it))) + ,n))) + +(defun -first (pred list) + "Returns the first x in LIST where (PRED x) is non-nil, else nil. + +To get the first item in the list no questions asked, use `car'." + (--first (funcall pred it) list)) + +(defmacro --last (form list) + "Anaphoric form of `-last'." + (let ((n (make-symbol "needle"))) + `(let (,n) + (--each ,list + (when ,form (setq ,n it))) + ,n))) + +(defun -last (pred list) + "Return the last x in LIST where (PRED x) is non-nil, else nil." + (--last (funcall pred it) list)) + +(defmacro --count (pred list) + "Anaphoric form of `-count'." + (let ((r (make-symbol "result"))) + `(let ((,r 0)) + (--each ,list (when ,pred (setq ,r (1+ ,r)))) + ,r))) + +(defun -count (pred list) + "Counts the number of items in LIST where (PRED item) is non-nil." + (--count (funcall pred it) list)) + +(defun ---truthy? (val) + (not (null val))) + +(defmacro --any? (form list) + "Anaphoric form of `-any?'." + `(---truthy? (--first ,form ,list))) + +(defun -any? (pred list) + "Returns t if (PRED x) is non-nil for any x in LIST, else nil. + +Alias: `-some?'" + (--any? (funcall pred it) list)) + +(defalias '-some? '-any?) +(defalias '--some? '--any?) + +(defalias '-any-p '-any?) +(defalias '--any-p '--any?) +(defalias '-some-p '-any?) +(defalias '--some-p '--any?) + +(defmacro --all? (form list) + "Anaphoric form of `-all?'." + (let ((a (make-symbol "all"))) + `(let ((,a t)) + (--each-while ,list ,a (setq ,a ,form)) + (---truthy? ,a)))) + +(defun -all? (pred list) + "Returns t if (PRED x) is non-nil for all x in LIST, else nil. + +Alias: `-every?'" + (--all? (funcall pred it) list)) + +(defalias '-every? '-all?) +(defalias '--every? '--all?) + +(defalias '-all-p '-all?) +(defalias '--all-p '--all?) +(defalias '-every-p '-all?) +(defalias '--every-p '--all?) + +(defmacro --none? (form list) + "Anaphoric form of `-none?'." + `(--all? (not ,form) ,list)) + +(defun -none? (pred list) + "Returns t if (PRED x) is nil for all x in LIST, else nil." + (--none? (funcall pred it) list)) + +(defalias '-none-p '-none?) +(defalias '--none-p '--none?) + +(defmacro --only-some? (form list) + "Anaphoric form of `-only-some?'." + (let ((y (make-symbol "yes")) + (n (make-symbol "no"))) + `(let (,y ,n) + (--each-while ,list (not (and ,y ,n)) + (if ,form (setq ,y t) (setq ,n t))) + (---truthy? (and ,y ,n))))) + +(defun -only-some? (pred list) + "Returns `t` if there is a mix of items in LIST that matches and does not match PRED. +Returns `nil` both if all items match the predicate, and if none of the items match the predicate." + (--only-some? (funcall pred it) list)) + +(defalias '-only-some-p '-only-some?) +(defalias '--only-some-p '--only-some?) + +(defun -slice (list from &optional to) + "Return copy of LIST, starting from index FROM to index TO. +FROM or TO may be negative." + (let ((length (length list)) + (new-list nil) + (index 0)) + ;; to defaults to the end of the list + (setq to (or to length)) + ;; handle negative indices + (when (< from 0) + (setq from (mod from length))) + (when (< to 0) + (setq to (mod to length))) + + ;; iterate through the list, keeping the elements we want + (while (< index to) + (when (>= index from) + (!cons (car list) new-list)) + (!cdr list) + (setq index (1+ index))) + (nreverse new-list))) + +(defun -take (n list) + "Returns a new list of the first N items in LIST, or all items if there are fewer than N." + (let (result) + (--dotimes n + (when list + (!cons (car list) result) + (!cdr list))) + (nreverse result))) + +(defun -drop (n list) + "Returns the tail of LIST without the first N items." + (--dotimes n (!cdr list)) + list) + +(defmacro --take-while (form list) + "Anaphoric form of `-take-while'." + (let ((r (make-symbol "result"))) + `(let (,r) + (--each-while ,list ,form (!cons it ,r)) + (nreverse ,r)))) + +(defun -take-while (pred list) + "Returns a new list of successive items from LIST while (PRED item) returns a non-nil value." + (--take-while (funcall pred it) list)) + +(defmacro --drop-while (form list) + "Anaphoric form of `-drop-while'." + (let ((l (make-symbol "list"))) + `(let ((,l ,list)) + (while (and ,l (let ((it (car ,l))) ,form)) + (!cdr ,l)) + ,l))) + +(defun -drop-while (pred list) + "Returns the tail of LIST starting from the first item for which (PRED item) returns nil." + (--drop-while (funcall pred it) list)) + +(defun -split-at (n list) + "Returns a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list." + (let (result) + (--dotimes n + (when list + (!cons (car list) result) + (!cdr list))) + (list (nreverse result) list))) + +(defun -insert-at (n x list) + "Returns a list with X inserted into LIST at position N." + (let ((split-list (-split-at n list))) + (nconc (car split-list) (cons x (cadr split-list))))) + +(defmacro --split-with (pred list) + "Anaphoric form of `-split-with'." + (let ((l (make-symbol "list")) + (r (make-symbol "result")) + (c (make-symbol "continue"))) + `(let ((,l ,list) + (,r nil) + (,c t)) + (while (and ,l ,c) + (let ((it (car ,l))) + (if (not ,pred) + (setq ,c nil) + (!cons it ,r) + (!cdr ,l)))) + (list (nreverse ,r) ,l)))) + +(defun -split-with (pred list) + "Returns a list of ((-take-while PRED LIST) (-drop-while PRED LIST)), in no more than one pass through the list." + (--split-with (funcall pred it) list)) + +(defmacro --separate (form list) + "Anaphoric form of `-separate'." + (let ((y (make-symbol "yes")) + (n (make-symbol "no"))) + `(let (,y ,n) + (--each ,list (if ,form (!cons it ,y) (!cons it ,n))) + (list (nreverse ,y) (nreverse ,n))))) + +(defun -separate (pred list) + "Returns a list of ((-filter PRED LIST) (-remove PRED LIST)), in one pass through the list." + (--separate (funcall pred it) list)) + +(defun ---partition-all-in-steps-reversed (n step list) + "Private: Used by -partition-all-in-steps and -partition-in-steps." + (when (< step 1) + (error "Step must be a positive number, or you're looking at some juicy infinite loops.")) + (let ((result nil) + (len 0)) + (while list + (!cons (-take n list) result) + (setq list (-drop step list))) + result)) + +(defun -partition-all-in-steps (n step list) + "Returns a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart. +The last groups may contain less than N items." + (nreverse (---partition-all-in-steps-reversed n step list))) + +(defun -partition-in-steps (n step list) + "Returns a new list with the items in LIST grouped into N-sized sublists at offsets STEP apart. +If there are not enough items to make the last group N-sized, +those items are discarded." + (let ((result (---partition-all-in-steps-reversed n step list))) + (while (and result (< (length (car result)) n)) + (!cdr result)) + (nreverse result))) + +(defun -partition-all (n list) + "Returns a new list with the items in LIST grouped into N-sized sublists. +The last group may contain less than N items." + (-partition-all-in-steps n n list)) + +(defun -partition (n list) + "Returns a new list with the items in LIST grouped into N-sized sublists. +If there are not enough items to make the last group N-sized, +those items are discarded." + (-partition-in-steps n n list)) + +(defmacro --partition-by (form list) + "Anaphoric form of `-partition-by'." + (let ((r (make-symbol "result")) + (s (make-symbol "sublist")) + (v (make-symbol "value")) + (n (make-symbol "new-value")) + (l (make-symbol "list"))) + `(let ((,l ,list)) + (when ,l + (let* ((,r nil) + (it (car ,l)) + (,s (list it)) + (,v ,form) + (,l (cdr ,l))) + (while ,l + (let* ((it (car ,l)) + (,n ,form)) + (unless (equal ,v ,n) + (!cons (nreverse ,s) ,r) + (setq ,s nil) + (setq ,v ,n)) + (!cons it ,s) + (!cdr ,l))) + (!cons (nreverse ,s) ,r) + (nreverse ,r)))))) + +(defun -partition-by (fn list) + "Applies FN to each item in LIST, splitting it each time FN returns a new value." + (--partition-by (funcall fn it) list)) + +(defmacro --partition-by-header (form list) + "Anaphoric form of `-partition-by-header'." + (let ((r (make-symbol "result")) + (s (make-symbol "sublist")) + (h (make-symbol "header-value")) + (b (make-symbol "seen-body?")) + (n (make-symbol "new-value")) + (l (make-symbol "list"))) + `(let ((,l ,list)) + (when ,l + (let* ((,r nil) + (it (car ,l)) + (,s (list it)) + (,h ,form) + (,b nil) + (,l (cdr ,l))) + (while ,l + (let* ((it (car ,l)) + (,n ,form)) + (if (equal ,h, n) + (when ,b + (!cons (nreverse ,s) ,r) + (setq ,s nil) + (setq ,b nil)) + (setq ,b t)) + (!cons it ,s) + (!cdr ,l))) + (!cons (nreverse ,s) ,r) + (nreverse ,r)))))) + +(defun -partition-by-header (fn list) + "Applies FN to the first item in LIST. That is the header + value. Applies FN to each item in LIST, splitting it each time + FN returns the header value, but only after seeing at least one + other value (the body)." + (--partition-by-header (funcall fn it) list)) + +(defmacro --group-by (form list) + "Anaphoric form of `-group-by'." + (let ((l (make-symbol "list")) + (v (make-symbol "value")) + (k (make-symbol "key")) + (r (make-symbol "result"))) + `(let ((,l ,list) + ,r) + ;; Convert `list' to an alist and store it in `r'. + (while ,l + (let* ((,v (car ,l)) + (it ,v) + (,k ,form) + (kv (assoc ,k ,r))) + (if kv + (setcdr kv (cons ,v (cdr kv))) + (push (list ,k ,v) ,r)) + (setq ,l (cdr ,l)))) + ;; Reverse lists in each group. + (let ((rest ,r)) + (while rest + (let ((kv (car rest))) + (setcdr kv (nreverse (cdr kv)))) + (setq rest (cdr rest)))) + ;; Reverse order of keys. + (nreverse ,r)))) + +(defun -group-by (fn list) + "Separate LIST into an alist whose keys are FN applied to the +elements of LIST. Keys are compared by `equal'." + (--group-by (funcall fn it) list)) + +(defun -interpose (sep list) + "Returns a new list of all elements in LIST separated by SEP." + (let (result) + (when list + (!cons (car list) result) + (!cdr list)) + (while list + (setq result (cons (car list) (cons sep result))) + (!cdr list)) + (nreverse result))) + +(defun -interleave (&rest lists) + "Returns a new list of the first item in each list, then the second etc." + (let (result) + (while (-none? 'null lists) + (--each lists (!cons (car it) result)) + (setq lists (-map 'cdr lists))) + (nreverse result))) + +(defmacro --zip-with (form list1 list2) + "Anaphoric form of `-zip-with'. + +The elements in list1 is bound as `it`, the elements in list2 as `other`." + (let ((r (make-symbol "result")) + (l1 (make-symbol "list1")) + (l2 (make-symbol "list2"))) + `(let ((,r nil) + (,l1 ,list1) + (,l2 ,list2)) + (while (and ,l1 ,l2) + (let ((it (car ,l1)) + (other (car ,l2))) + (!cons ,form ,r) + (!cdr ,l1) + (!cdr ,l2))) + (nreverse ,r)))) + +(defun -zip-with (fn list1 list2) + "Zip the two lists LIST1 and LIST2 using a function FN. This +function is applied pairwise taking as first argument element of +LIST1 and as second argument element of LIST2 at corresponding +position. + +The anaphoric form `--zip-with' binds the elements from LIST1 as `it`, +and the elements from LIST2 as `other`." + (--zip-with (funcall fn it other) list1 list2)) + +(defun -zip (list1 list2) + "Zip the two lists together. Return the list where elements +are cons pairs with car being element from LIST1 and cdr being +element from LIST2. The length of the returned list is the +length of the shorter one." + (-zip-with 'cons list1 list2)) + +(defun -partial (fn &rest args) + "Takes a function FN and fewer than the normal arguments to FN, +and returns a fn that takes a variable number of additional ARGS. +When called, the returned function calls FN with ARGS first and +then additional args." + (apply 'apply-partially fn args)) + +(defun -rpartial (fn &rest args) + "Takes a function FN and fewer than the normal arguments to FN, +and returns a fn that takes a variable number of additional ARGS. +When called, the returned function calls FN with the additional +args first and then ARGS. + +Requires Emacs 24 or higher." + `(closure (t) (&rest args) + (apply ',fn (append args ',args)))) + +(defun -applify (fn) + "Changes an n-arity function FN to a 1-arity function that +expects a list with n items as arguments" + (apply-partially 'apply fn)) + +(defmacro -> (x &optional form &rest more) + "Threads the expr through the forms. Inserts X as the second +item in the first form, making a list of it if it is not a list +already. If there are more forms, inserts the first form as the +second item in second form, etc." + (cond + ((null form) x) + ((null more) (if (listp form) + `(,(car form) ,x ,@(cdr form)) + (list form x))) + (:else `(-> (-> ,x ,form) ,@more)))) + +(defmacro ->> (x form &rest more) + "Threads the expr through the forms. Inserts X as the last item +in the first form, making a list of it if it is not a list +already. If there are more forms, inserts the first form as the +last item in second form, etc." + (if (null more) + (if (listp form) + `(,(car form) ,@(cdr form) ,x) + (list form x)) + `(->> (->> ,x ,form) ,@more))) + +(defmacro --> (x form &rest more) + "Threads the expr through the forms. Inserts X at the position +signified by the token `it' in the first form. If there are more +forms, inserts the first form at the position signified by `it' +in in second form, etc." + (if (null more) + (if (listp form) + (--map-when (eq it 'it) x form) + (list form x)) + `(--> (--> ,x ,form) ,@more))) + +(put '-> 'lisp-indent-function 1) +(put '->> 'lisp-indent-function 1) +(put '--> 'lisp-indent-function 1) + +(defmacro -when-let (var-val &rest body) + "If VAL evaluates to non-nil, bind it to VAR and execute body. +VAR-VAL should be a (VAR VAL) pair." + (let ((var (car var-val)) + (val (cadr var-val))) + `(let ((,var ,val)) + (when ,var + ,@body)))) + +(defmacro -when-let* (vars-vals &rest body) + "If all VALS evaluate to true, bind them to their corresponding + VARS and execute body. VARS-VALS should be a list of (VAR VAL) + pairs (corresponding to bindings of `let*')." + (if (= (length vars-vals) 1) + `(-when-let ,(car vars-vals) + ,@body) + `(-when-let ,(car vars-vals) + (-when-let* ,(cdr vars-vals) + ,@body)))) + +(defmacro --when-let (val &rest body) + "If VAL evaluates to non-nil, bind it to `it' and execute +body." + `(let ((it ,val)) + (when it + ,@body))) + +(defmacro -if-let (var-val then &optional else) + "If VAL evaluates to non-nil, bind it to VAR and do THEN, +otherwise do ELSE. VAR-VAL should be a (VAR VAL) pair." + (let ((var (car var-val)) + (val (cadr var-val))) + `(let ((,var ,val)) + (if ,var ,then ,else)))) + +(defmacro -if-let* (vars-vals then &optional else) + "If all VALS evaluate to true, bind them to their corresponding + VARS and do THEN, otherwise do ELSE. VARS-VALS should be a list + of (VAR VAL) pairs (corresponding to the bindings of `let*')." + (let ((first-pair (car vars-vals)) + (rest (cdr vars-vals))) + (if (= (length vars-vals) 1) + `(-if-let ,first-pair ,then ,else) + `(-if-let ,first-pair + (-if-let* ,rest ,then ,else) + ,else)))) + +(defmacro --if-let (val then &optional else) + "If VAL evaluates to non-nil, bind it to `it' and do THEN, +otherwise do ELSE." + `(let ((it ,val)) + (if it ,then ,else))) + +(put '-when-let 'lisp-indent-function 1) +(put '-when-let* 'lisp-indent-function 1) +(put '--when-let 'lisp-indent-function 1) +(put '-if-let 'lisp-indent-function 1) +(put '-if-let* 'lisp-indent-function 1) +(put '--if-let 'lisp-indent-function 1) + +(defun -distinct (list) + "Return a new list with all duplicates removed. +The test for equality is done with `equal', +or with `-compare-fn' if that's non-nil. + +Alias: `-uniq'" + (let (result) + (--each list (unless (-contains? result it) (!cons it result))) + (nreverse result))) + +(defun -union (list list2) + "Return a new list containing the elements of LIST1 and elements of LIST2 that are not in LIST1. +The test for equality is done with `equal', +or with `-compare-fn' if that's non-nil." + (let (result) + (--each list (!cons it result)) + (--each list2 (unless (-contains? result it) (!cons it result))) + (nreverse result))) + +(defalias '-uniq '-distinct) + +(defun -intersection (list list2) + "Return a new list containing only the elements that are members of both LIST and LIST2. +The test for equality is done with `equal', +or with `-compare-fn' if that's non-nil." + (--filter (-contains? list2 it) list)) + +(defun -difference (list list2) + "Return a new list with only the members of LIST that are not in LIST2. +The test for equality is done with `equal', +or with `-compare-fn' if that's non-nil." + (--filter (not (-contains? list2 it)) list)) + +(defvar -compare-fn nil + "Tests for equality use this function or `equal' if this is nil. +It should only be set using dynamic scope with a let, like: +(let ((-compare-fn =)) (-union numbers1 numbers2 numbers3)") + +(defun -contains? (list element) + "Return whether LIST contains ELEMENT. +The test for equality is done with `equal', +or with `-compare-fn' if that's non-nil." + (not + (null + (cond + ((null -compare-fn) (member element list)) + ((eq -compare-fn 'eq) (memq element list)) + ((eq -compare-fn 'eql) (memql element list)) + (t + (let ((lst list)) + (while (and lst + (not (funcall -compare-fn element (car lst)))) + (setq lst (cdr lst))) + lst)))))) + +(defalias '-contains-p '-contains?) + +(defun -sort (predicate list) + "Sort LIST, stably, comparing elements using PREDICATE. +Returns the sorted list. LIST is NOT modified by side effects. +PREDICATE is called with two elements of LIST, and should return non-nil +if the first element should sort before the second." + (sort (copy-sequence list) predicate)) + +(defmacro --sort (form list) + "Anaphoric form of `-sort'." + (declare (debug t)) + `(-sort (lambda (it other) ,form) ,list)) + +(defun -repeat (n x) + "Return a list with X repeated N times. +Returns nil if N is less than 1." + (let (ret) + (--dotimes n (!cons x ret)) + ret)) + +(defun -sum (list) + "Return the sum of LIST." + (apply '+ list)) + +(defun -product (list) + "Return the product of LIST." + (apply '* list)) + +(eval-after-load "lisp-mode" + '(progn + (let ((new-keywords '( + "--each" + "-each" + "--each-while" + "-each-while" + "--dotimes" + "-dotimes" + "-map" + "--map" + "--reduce-from" + "-reduce-from" + "--reduce" + "-reduce" + "--reduce-r-from" + "-reduce-r-from" + "--reduce-r" + "-reduce-r" + "--filter" + "-filter" + "-select" + "--select" + "--remove" + "-remove" + "-reject" + "--reject" + "--keep" + "-keep" + "-flatten" + "-concat" + "--mapcat" + "-mapcat" + "--first" + "-first" + "--any?" + "-any?" + "-some?" + "--some?" + "-any-p" + "--any-p" + "-some-p" + "--some-p" + "--all?" + "-all?" + "-every?" + "--every?" + "-all-p" + "--all-p" + "-every-p" + "--every-p" + "--none?" + "-none?" + "-none-p" + "--none-p" + "-only-some?" + "--only-some?" + "-only-some-p" + "--only-some-p" + "-take" + "-drop" + "--take-while" + "-take-while" + "--drop-while" + "-drop-while" + "-split-at" + "-insert-at" + "--split-with" + "-split-with" + "-partition" + "-partition-in-steps" + "-partition-all" + "-partition-all-in-steps" + "-interpose" + "-interleave" + "--zip-with" + "-zip-with" + "-zip" + "--map-indexed" + "-map-indexed" + "--map-when" + "-map-when" + "--replace-where" + "-replace-where" + "-partial" + "-rpartial" + "->" + "->>" + "-->" + "-when-let" + "-when-let*" + "--when-let" + "-if-let" + "-if-let*" + "--if-let" + "-distinct" + "-intersection" + "-difference" + "-contains?" + "-contains-p" + "-repeat" + "-cons*" + "-sum" + "-product" + )) + (special-variables '( + "it" + "it-index" + "acc" + "other" + ))) + (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "\\<" (regexp-opt special-variables 'paren) "\\>") + 1 font-lock-variable-name-face)) 'append) + (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "(\\s-*" (regexp-opt new-keywords 'paren) "\\>") + 1 font-lock-keyword-face)) 'append)) + (--each (buffer-list) + (with-current-buffer it + (when (and (eq major-mode 'emacs-lisp-mode) + (boundp 'font-lock-mode) + font-lock-mode) + (font-lock-refresh-defaults)))))) + +(provide 'dash) +;;; dash.el ends here diff --git a/emacs.d/elpa/dash-1.5.0/dash.elc b/emacs.d/elpa/dash-1.5.0/dash.elc new file mode 100644 index 0000000000000000000000000000000000000000..06a3f6e56c4157cb499d5e5e6fc64ccd64bc94cf GIT binary patch literal 32825 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 +;; URL: https://github.com/d11wtq/grizzl +;; Version: 0.1.1 +;; Keywords: convenience, usability + +;; This file is NOT part of GNU Emacs. + +;;; --- License + +;; Licensed under the same terms as Emacs. + +;;; --- Commentary + +;; Grizzl provides a fuzzy completion framework for general purpose +;; use in Emacs Lisp projects. +;; +;; grizzl-core.el provides the underlying data structures and sesrch +;; algorithm without any UI attachment. At the core, a fuzzy search +;; index is created from a list of strings, using `grizzl-make-index'. +;; A fuzzy search term is then used to get a result from this index +;; with `grizzl-search'. Because grizzl considers the usage of a +;; fuzzy search index to operate in real-time as a user enters a +;; search term in the minibuffer, the framework optimizes for this use +;; case. Any result can be passed back into `grizzl-search' as a hint +;; to continue searching. The search algorithm is able to understand +;; insertions and deletions and therefore minimizes the work it needs +;; to do in this case. The intended use here is to collect a result +;; on each key press and feed that result into the search for the next +;; key press. Once a search is complete, the matched strings are then +;; read, using `grizzl-result-strings'. The results are ordered on the +;; a combination of the Levenshtein Distance and a character-proximity +;; scoring calculation. This means shorter strings are favoured, but +;; adjacent letters are more heavily favoured. +;; +;; It is assumed that the index will be re-used across multiple +;; searches on larger sets of data. +;; +;; + +(eval-when-compile + (require 'cl-lib)) + +;;; --- Public Functions + +;;;###autoload +(defun grizzl-make-index (strings &rest options) + "Makes an index from the list STRINGS for use with `grizzl-search'. + +If :PROGRESS-FN is given as a keyword argument, it is called repeatedly +with integers N and TOTAL. + +If :CASE-SENSITIVE is specified as a non-nil keyword argument, the index +will be created case-sensitive, otherwise it will be case-insensitive." + (let ((lookup-table (make-hash-table)) + (total-strs (length strings)) + (case-sensitive (plist-get options :case-sensitive)) + (progress-fn (plist-get options :progress-fn)) + (string-data (vconcat (mapcar (lambda (s) + (cons s (length s))) + strings)))) + (reduce (lambda (list-offset str) + (grizzl-index-insert str list-offset lookup-table + :case-sensitive case-sensitive) + (when progress-fn + (funcall progress-fn (1+ list-offset) total-strs)) + (1+ list-offset)) + strings + :initial-value 0) + (maphash (lambda (char str-map) + (maphash (lambda (list-offset locations) + (puthash list-offset (reverse locations) str-map)) + str-map)) lookup-table) + `((case-sensitive . ,case-sensitive) + (lookup-table . ,lookup-table) + (string-data . ,string-data)))) + +;;;###autoload +(defun grizzl-search (term index &optional old-result) + "Fuzzy searches for TERM in INDEX prepared with `grizzl-make-index'. + +OLD-RESULT may be specified as an existing search result to increment from. +The result can be read with `grizzl-result-strings'." + (let* ((cased-term (if (grizzl-index-case-sensitive-p index) + term + (downcase term))) + (result (grizzl-rewind-result cased-term index old-result)) + (matches (copy-hash-table (grizzl-result-matches result))) + (from-pos (length (grizzl-result-term result))) + (remainder (substring cased-term from-pos)) + (lookup-table (grizzl-lookup-table index))) + (reduce (lambda (acc-res ch) + (let ((sub-table (gethash ch lookup-table))) + (if (not sub-table) + (clrhash matches) + (grizzl-search-increment sub-table matches)) + (grizzl-cons-result cased-term matches acc-res))) + remainder + :initial-value result))) + +;;;###autoload +(defun grizzl-result-count (result) + "Returns the number of matches present in RESULT." + (hash-table-count (grizzl-result-matches result))) + +;;;###autoload +(defun grizzl-result-strings (result index &rest options) + "Returns the ordered list of matched strings in RESULT, using INDEX. + +If the :START option is specified, results are read from the given offset. +If the :END option is specified, up to :END results are returned." + (let* ((matches (grizzl-result-matches result)) + (strings (grizzl-index-strings index)) + (loaded '()) + (start (plist-get options :start)) + (end (plist-get options :end))) + (maphash (lambda (string-offset char-offset) + (push string-offset loaded)) + matches) + (let* ((ordered (sort loaded + (lambda (a b) + (< (cadr (gethash a matches)) + (cadr (gethash b matches)))))) + (best (if (or start end) + (delete-if-not 'identity + (subseq ordered (or start 0) end)) + ordered))) + (mapcar (lambda (n) + (car (elt strings n))) + best)))) + +;;; --- Private Functions + +(defun grizzl-cons-result (term matches results) + "Build a new result for TERM and hash-table MATCHES consed with RESULTS." + (cons (cons term matches) results)) + +(defun grizzl-rewind-result (term index result) + "Adjusts RESULT according to TERM, ready for a new search." + (if result + (let* ((old-term (grizzl-result-term result)) + (new-len (length term)) + (old-len (length old-term))) + (if (and (>= new-len old-len) + (string-equal old-term (substring term 0 old-len))) + result + (grizzl-rewind-result term index (cdr result)))) + (grizzl-cons-result "" (grizzl-base-matches index) nil))) + +(defun grizzl-base-matches (index) + "Returns the full set of matches in INDEX, with an out-of-bound offset." + (let ((matches (make-hash-table))) + (reduce (lambda (n s-len) + (puthash n (list -1 0 (cdr s-len)) matches) + (1+ n)) + (grizzl-index-strings index) + :initial-value 0) + matches)) + +(defun grizzl-result-term (result) + "Returns the search term used to find the matches in RESULT." + (car (car result))) + +(defun grizzl-result-matches (result) + "Returns the internal hash used to track the matches in RESULT." + (cdar result)) + +(defun grizzl-index-insert (string list-offset index &rest options) + "Inserts STRING at LIST-OFFSET into INDEX." + (let ((case-sensitive (plist-get options :case-sensitive))) + (reduce (lambda (char-offset cs-char) + (let* ((char (if case-sensitive + cs-char + (downcase cs-char))) + (str-map (or (gethash char index) + (puthash char (make-hash-table) index))) + (offsets (gethash list-offset str-map))) + (puthash list-offset + (cons char-offset offsets) + str-map) + (1+ char-offset))) + string + :initial-value 0))) + +(defun grizzl-lookup-table (index) + "Returns the lookup table portion of INDEX." + (cdr (assoc 'lookup-table index))) + +(defun grizzl-index-strings (index) + "Returns the vector of strings stored in INDEX." + (cdr (assoc 'string-data index))) + +(defun grizzl-index-case-sensitive-p (index) + "Predicate to test of INDEX is case-sensitive." + (cdr (assoc 'case-sensitive index))) + +(defun grizzl-search-increment (sub-table result) + "Use the search lookup table to filter already-accumulated results." + (cl-flet ((next-offset (key current sub-table) + (find-if (lambda (v) + (> v current)) + (gethash key sub-table)))) + (maphash (lambda (k v) + (let* ((oldpos (car v)) + (oldrank (cadr v)) + (len (caddr v)) + (newpos (next-offset k oldpos sub-table))) + (if newpos + (puthash k (list newpos + (grizzl-inc-rank oldrank oldpos newpos len) + len) + result) + (remhash k result)))) + result))) + +(defun grizzl-inc-rank (oldrank oldpos newpos len) + "Increment the current match distance as a new char is matched." + (let ((distance (if (< oldpos 0) 1 (- newpos oldpos)))) + (+ oldrank (* len (* distance distance))))) + +(provide 'grizzl-core) + +;;; grizzl-core.el ends here diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl-core.elc b/emacs.d/elpa/grizzl-0.1.1/grizzl-core.elc new file mode 100644 index 0000000000000000000000000000000000000000..9d43cfd19462ee5326da2fb32bebcc80ab7bf288 GIT binary patch literal 6324 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 ZqmJI?MD+>>Zr4!j^J7!`?|_~4{{luJz1;u+ literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.el b/emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.el new file mode 100644 index 0000000..e296607 --- /dev/null +++ b/emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.el @@ -0,0 +1,3 @@ +(define-package "grizzl" "0.1.1" + "Fuzzy Search Library & Completing Read" + '((cl-lib "0.1"))) diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.elc b/emacs.d/elpa/grizzl-0.1.1/grizzl-pkg.elc new file mode 100644 index 0000000000000000000000000000000000000000..225cc6f542077f16d608c9551527a1c300adf00b GIT binary patch literal 642 zcmbtS!A`?44Bfduz}4yjHfc@Q6~VS%*rp*(8WLjT1KcESqoqleq@eZd$vQwFj`$MU zetGXXPPW;tuLgrbkYyRHb=?Tb8RRF(4R=nWDw$Rft8-$bC!{N_kI}QyL~4o>w1Pv+ zVcC|Dq%fH+(z``^57SAK_KbzmH58r`;#bR!jepX{gx5$dVKJ8t#-$NmC!+~TNb;35 z$C7Z_Qwar|GaTMLkMP3NTauEb@4X9G0ZQ+uaiSI-IuEcU=$nU1*o%kOatrLFuoe`U zrq&suN;~#lV;vx4e)eyjWKO2@KO9VZ4y7GXtsHuA>xyXRD=J#<*V`@73Jp@{O^$nc zR1B;JiVAWLQsXa?&tWWZG*WN_uJXWXdeQYu`B$6`{5OIi7&2Z6#iIu45lar?WmO@B v{j&V|*mm6s_I?Oj!A|4`%?Ymi4<)(tj|?vySqL}7A(fF7d4Dw=jYh!-W*Wd$ literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl-read.el b/emacs.d/elpa/grizzl-0.1.1/grizzl-read.el new file mode 100644 index 0000000..e08a2c2 --- /dev/null +++ b/emacs.d/elpa/grizzl-0.1.1/grizzl-read.el @@ -0,0 +1,186 @@ +;;; grizzl-read.el --- A fuzzy completing-read backed by grizzl. + +;; Copyright © 2013 Chris Corbyn +;; +;; Author: Chris Corbyn +;; URL: https://github.com/d11wtq/grizzl +;; Version: 0.1.1 +;; Keywords: convenience, usability + +;; This file is NOT part of GNU Emacs. + +;;; --- License + +;; Licensed under the same terms as Emacs. + +;;; --- Commentary + +;; grizzl-read.el provides an implementation of the built-in Emacs +;; completing-read function, except it is backed by the grizzl fuzzy +;; search index. The goals are similar to ido-mode and helm, but grizzl +;; is heavily optimized for large data-sets, and as-such uses a +;; persistent fuzzy search index in its algorithm. +;; +;; The indexing and searching algorithm itself is defined in grizzl-core.el +;; with grizzl-read.el simply wrapping the search in a minibuffer with a +;; minor-mode defined. +;; +;; ---- Usage +;; +;; Call `grizzl-completing-read' with an index returned by +;; `grizzl-make-index': +;; +;; (defvar *index* (grizzl-make-index '("one" "two" "three"))) +;; (grizzl-completing-read "Number: " index) +;; +;; When the user hits ENTER, either one of the strings is returned on +;; success, or nil of nothing matched. +;; +;; The arrow keys can be used to navigate within the results. +;; + +(eval-when-compile + (require 'cl-lib)) + +;;; --- Configuration Variables + +(defvar *grizzl-read-max-results* 10 + "The maximum number of results to show in `grizzl-completing-read'.") + +;;; --- Runtime Processing Variables + +(defvar *grizzl-current-result* nil + "The search result in `grizzl-completing-read'.") + +(defvar *grizzl-current-selection* 0 + "The selected offset in `grizzl-completing-read'.") + +;;; --- Minor Mode Definition + +(defvar *grizzl-keymap* (make-sparse-keymap) + "Internal keymap used by the minor-mode in `grizzl-completing-read'.") + +(define-key *grizzl-keymap* (kbd "") 'grizzl-set-selection+1) +(define-key *grizzl-keymap* (kbd "C-p") 'grizzl-set-selection+1) +(define-key *grizzl-keymap* (kbd "") 'grizzl-set-selection-1) +(define-key *grizzl-keymap* (kbd "C-n") 'grizzl-set-selection-1) + +(define-minor-mode grizzl-mode + "Toggle the internal mode used by `grizzl-completing-read'." + nil + " Grizzl" + *grizzl-keymap*) + +;;; --- Public Functions + +;;;###autoload +(defun grizzl-completing-read (prompt index) + "Performs a completing-read in the minibuffer using INDEX to fuzzy search. +Each key pressed in the minibuffer filters down the list of matches." + (minibuffer-with-setup-hook + (lambda () + (setq *grizzl-current-result* nil) + (setq *grizzl-current-selection* 0) + (grizzl-mode 1) + (lexical-let* + ((hookfun (lambda () + (setq *grizzl-current-result* + (grizzl-search (minibuffer-contents) + index + *grizzl-current-result*)) + (grizzl-display-result index prompt))) + (exitfun (lambda () + (grizzl-mode -1) + (remove-hook 'post-command-hook hookfun t)))) + (add-hook 'minibuffer-exit-hook exitfun nil t) + (add-hook 'post-command-hook hookfun nil t))) + (read-from-minibuffer ">>> ") + (grizzl-selected-result index))) + +;;;###autoload +(defun grizzl-selected-result (index) + "Get the selected string from INDEX in a `grizzl-completing-read'." + (elt (grizzl-result-strings *grizzl-current-result* index + :start 0 + :end *grizzl-read-max-results*) + (grizzl-current-selection))) + +;;;###autoload +(defun grizzl-set-selection+1 () + "Move the selection up one row in `grizzl-completing-read'." + (interactive) + (grizzl-move-selection 1)) + +;;;###autoload +(defun grizzl-set-selection-1 () + "Move the selection down one row in `grizzl-completing-read'." + (interactive) + (grizzl-move-selection -1)) + +;;; --- Private Functions + +(defun grizzl-move-selection (delta) + "Move the selection by DELTA rows in `grizzl-completing-read'." + (setq *grizzl-current-selection* (+ (grizzl-current-selection) delta)) + (when (not (= (grizzl-current-selection) *grizzl-current-selection*)) + (beep))) + +(defun grizzl-display-result (index prompt) + "Renders a series of overlays to list the matches in the result." + (let* ((matches (grizzl-result-strings *grizzl-current-result* index + :start 0 + :end *grizzl-read-max-results*))) + (delete-all-overlays) + (overlay-put (make-overlay (point-min) (point-min)) + 'before-string + (format "%s\n%s\n" + (mapconcat 'identity + (grizzl-map-format-matches matches) + "\n") + (grizzl-format-prompt-line prompt))) + (set-window-text-height nil (max 3 (+ 2 (length matches)))))) + +(defun grizzl-map-format-matches (matches) + "Convert the set of string MATCHES into propertized text objects." + (if (= 0 (length matches)) + (list (propertize "-- NO MATCH --" 'face 'outline-3)) + (cdr (reduce (lambda (acc str) + (let* ((idx (car acc)) + (lst (cdr acc)) + (sel (= idx (grizzl-current-selection)))) + (cons (1+ idx) + (cons (grizzl-format-match str sel) lst)))) + matches + :initial-value '(0))))) + +(defun grizzl-format-match (match-str selected) + "Default match string formatter in `grizzl-completing-read'. + +MATCH-STR is the string in the selection list and SELECTED is non-nil +if this is the current selection." + (let ((margin (if selected "> " " ")) + (face (if selected 'diredp-symlink 'default))) + (propertize (format "%s%s" margin match-str) 'face face))) + +(defun grizzl-format-prompt-line (prompt) + "Returns a string to render a full-width prompt in `grizzl-completing-read'." + (let* ((count (grizzl-result-count *grizzl-current-result*)) + (match-info (format " (%d candidate%s) ---- *-" + count (if (= count 1) "" "s")))) + (concat (propertize (format "-*%s *-" prompt) 'face 'modeline-inactive) + (propertize " " + 'face 'modeline-inactive + 'display `(space :align-to (- right + ,(1+ (length match-info))))) + (propertize match-info 'face 'modeline-inactive)))) + +(defun grizzl-current-selection () + "Get the currently selected index in `grizzl-completing-read'." + (let ((max-selection + (min (1- *grizzl-read-max-results*) + (1- (grizzl-result-count *grizzl-current-result*))))) + (max 0 (min max-selection *grizzl-current-selection*)))) + +(provide 'grizzl-read) + +;;; grizzl-read.el ends here diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl-read.elc b/emacs.d/elpa/grizzl-0.1.1/grizzl-read.elc new file mode 100644 index 0000000000000000000000000000000000000000..bd9687327858131ef67a1bec5906afd8c66d9ee7 GIT binary patch literal 6168 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 literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl.el b/emacs.d/elpa/grizzl-0.1.1/grizzl.el new file mode 100644 index 0000000..e60212c --- /dev/null +++ b/emacs.d/elpa/grizzl-0.1.1/grizzl.el @@ -0,0 +1,26 @@ +;;; grizzl.el --- Fast fuzzy search index for Emacs. + +;; Copyright © 2013 Chris Corbyn +;; +;; Author: Chris Corbyn +;; URL: https://github.com/d11wtq/grizzl +;; Version: 0.1.1 +;; Keywords: convenience, usability + +;; This file is NOT part of GNU Emacs. + +;;; --- License + +;; Licensed under the same terms as Emacs. + +;;; --- Commentary + +;; This package is broken into separate files. +;; + +(require 'grizzl-core) +(require 'grizzl-read) + +(provide 'grizzl) + +;;; grizzl.el ends here diff --git a/emacs.d/elpa/grizzl-0.1.1/grizzl.elc b/emacs.d/elpa/grizzl-0.1.1/grizzl.elc new file mode 100644 index 0000000000000000000000000000000000000000..0db5e592dd001a94fb8067408daa9cedc29824aa GIT binary patch literal 650 zcmbtR%T5C^4D5M-fUDsI5}SQhJlYGT>Y)-yNWcj=xJlYZWaE-#i`uWpyDcwq#FC{< zW;A2V!^zF~px5gq!{HFdRIiNH3T7Lac^#ugw@~D+u3He&Ta?#Cuj!p9VM(F|a`4b- z7&QwhD#$Me)!CprhcYj!&T;OkhBq7)oiueA?DK15M`Nu;MdpL?9$wg#w6X)p#|G0E?Kb}rOF43cmJmhH?k4`}# zkmz8h!4m!o*)J17qqjzTh)Wih)h?G0@~>(K_-`diay;8aok~&~j-IPL=PnMP%c6a> oU4DX!L7zc>egscmzct2d*xyvr_uFe!u=2DvY`NoKpgc)F07dD-?f?J) literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/projectile-0.9.2/projectile-autoloads.el b/emacs.d/elpa/projectile-0.9.2/projectile-autoloads.el new file mode 100644 index 0000000..dc2b1ae --- /dev/null +++ b/emacs.d/elpa/projectile-0.9.2/projectile-autoloads.el @@ -0,0 +1,52 @@ +;;; projectile-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads (projectile-global-mode projectile-mode) "projectile" +;;;;;; "projectile.el" (21002 9890 0 0)) +;;; Generated autoloads from projectile.el + +(autoload 'projectile-mode "projectile" "\ +Minor mode to assist project management and navigation. + +\\{projectile-mode-map} + +\(fn &optional ARG)" t nil) + +(defvar projectile-global-mode nil "\ +Non-nil if Projectile-Global mode is enabled. +See the command `projectile-global-mode' for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `projectile-global-mode'.") + +(custom-autoload 'projectile-global-mode "projectile" nil) + +(autoload 'projectile-global-mode "projectile" "\ +Toggle Projectile mode in all buffers. +With prefix ARG, enable Projectile-Global mode if ARG is positive; +otherwise, disable it. If called from Lisp, enable the mode if +ARG is omitted or nil. + +Projectile mode is enabled in all buffers where +`projectile-on' would do it. +See `projectile-mode' for more information on Projectile mode. + +\(fn &optional ARG)" t nil) + +;;;*** + +;;;### (autoloads nil nil ("projectile-pkg.el") (21002 9890 671493 +;;;;;; 0)) + +;;;*** + +(provide 'projectile-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; projectile-autoloads.el ends here diff --git a/emacs.d/elpa/projectile-0.9.2/projectile-pkg.el b/emacs.d/elpa/projectile-0.9.2/projectile-pkg.el new file mode 100644 index 0000000..9d4df7e --- /dev/null +++ b/emacs.d/elpa/projectile-0.9.2/projectile-pkg.el @@ -0,0 +1 @@ +(define-package "projectile" "0.9.2" "Manage and navigate projects in Emacs easily" (quote ((s "1.0.0") (dash "1.0.0")))) diff --git a/emacs.d/elpa/projectile-0.9.2/projectile-pkg.elc b/emacs.d/elpa/projectile-0.9.2/projectile-pkg.elc new file mode 100644 index 0000000000000000000000000000000000000000..8124c40339103526b33103ae94ab4fda6e26af6b GIT binary patch literal 672 zcmbtRO;5ux4BfeZfUDIDo3y4M!2Ba=C=HYddX7!R`z@PaznzwQ}}m)hC?Yqg*+6$R4~C#z{2bEIb_v zZjUvTGbrZQ)#AFUpeoAQz_|CWg?;3N{F%vf{*yKr)S_geaxxv}op&!JLj-4qScvLp zp*z%q%s{CvZ2E6-ihMd6sIJ6Jltb@ThX&9@UtQ3xe!~y}ERv!5)M)C0^{(P$mcK&gx+ZK5Sj?AW*@roIRA>?z<(o2lCh$_wv=@!4_FhV-zQ5U v9gY^?d$fJCpV#6^*BA&sf&9HyLe}P-!sU3(kd~qlMLL18LT" + projectile-current-version)) + +(defun projectile-invalidate-cache (arg) + "Remove the current project's files from `projectile-projects-cache'. + +With a prefix argument ARG prompts for the name of the project whose cache +to invalidate." + (interactive "P") + (let ((project-root + (if arg + (completing-read "Remove cache for: " + (projectile-hash-keys projectile-projects-cache)) + (projectile-project-root)))) + (remhash project-root projectile-projects-cache) + (projectile-serialize-cache) + (message "Invalidated Projectile cache for %s." + (propertize project-root 'face 'font-lock-keyword-face)))) + +(defun projectile-cache-project (project files) + "Cache PROJECTs FILES. +The cache is created both in memory and on the hard drive." + (when projectile-enable-caching + (puthash project files projectile-projects-cache) + (projectile-serialize-cache))) + +(defun projectile-project-root () + "Retrieves the root directory of a project if available. +The current directory is assumed to be the project's root otherwise." + (let ((project-root + (or (->> projectile-project-root-files + (--map (locate-dominating-file default-directory it)) + (-remove #'null) + (car) + (projectile-expand-file-name)) + (if projectile-require-project-root + (error "You're not into a project") + default-directory)))) + project-root)) + +(defun projectile-expand-file-name (file-name) + "A thin wrapper around `expand-file-name' that handles nil. +Expand FILE-NAME using `default-directory'." + (when file-name + (expand-file-name file-name))) + +(defun projectile-project-p () + "Check if we're in a project." + (condition-case nil + (projectile-project-root) + (error nil))) + +(defun projectile-project-name () + "Return project name." + (let ((project-root + (condition-case nil + (projectile-project-root) + (error default-directory)))) + (file-name-nondirectory (directory-file-name project-root)))) + +(defun projectile-get-project-directories () + "Get the list of project directories that are of interest to the user." + (-map (lambda (subdir) (concat (projectile-project-root) subdir)) + (or (car (projectile-parse-dirconfig-file)) '("")))) + +(defun projectile-dir-files (directory) + "List the files in DIRECTORY and in its sub-directories. +Files are returned as relative paths to the project root." + ;; check for a cache hit first if caching is enabled + (let ((files-list (and projectile-enable-caching + (gethash directory projectile-projects-cache))) + (root (projectile-project-root))) + ;; cache disabled or cache miss + (or files-list + (if projectile-use-native-indexing + (projectile-dir-files-native root directory) + ;; use external tools to get the project files + (projectile-dir-files-external root directory))))) + +(defun projectile-dir-files-native (root directory) + "Get the files for ROOT under DIRECTORY using just Emacs Lisp." + (message "Projectile is indexing %s. This may take a while." + (propertize directory 'face 'font-lock-keyword-face)) + ;; we need the files with paths relative to the project root + (-map (lambda (file) (s-chop-prefix root file)) + (projectile-index-directory directory (projectile-patterns-to-ignore)))) + +(defun projectile-dir-files-external (root directory) + "Get the files for ROOT under DIRECTORY using external tools." + (let ((default-directory directory) + (files-list nil)) + (setq files-list (-map (lambda (f) + (s-chop-prefix root (expand-file-name f directory))) + (projectile-get-repo-files))) + files-list)) + +(defun projectile-file-cached-p (file project) + "Check if FILE is already in PROJECT cache." + (member file (gethash project projectile-projects-cache))) + +(defun projectile-cache-current-file () + "Add the currently visited file to the cache." + (interactive) + (let* ((current-project (projectile-project-root)) + (current-file (file-relative-name (buffer-file-name (current-buffer)) current-project))) + (unless (projectile-file-cached-p current-file current-project) + (puthash current-project + (cons current-file (gethash current-project projectile-projects-cache)) + projectile-projects-cache) + (projectile-serialize-cache) + (message "File %s added to project %s cache." current-file current-project)))) + +;; cache opened files automatically to reduce the need for cache invalidation +(defun projectile-cache-files-find-file-hook () + "Function for caching files with `find-file-hook'." + (when (and (projectile-project-p) projectile-enable-caching) + (projectile-cache-current-file))) + +(defun projectile-cache-projects-find-file-hook () + "Function for caching projects with `find-file-hook'." + (when (projectile-project-p) + (projectile-add-known-project (projectile-project-root)) + (projectile-save-known-projects))) + +(defcustom projectile-git-command "git ls-files -zco --exclude-standard" + "Command used by projectile to get the files in a git project." + :group 'projectile + :type 'string) + +(defcustom projectile-hg-command "hg locate -0 -I ." + "Command used by projectile to get the files in a hg project." + :group 'projectile + :type 'string) + +(defcustom projectile-fossil-command "fossil ls" + "Command used by projectile to get the files in a fossil project." + :group 'projectile + :type 'string) + +(defcustom projectile-bzr-command "bzr ls --versioned -0" + "Command used by projectile to get the files in a bazaar project." + :group 'projectile + :type 'string) + +(defcustom projectile-darcs-command "darcs show files -0 . " + "Command used by projectile to get the files in a darcs project." + :group 'projectile + :type 'string) + +(defcustom projectile-svn-command "find . -type f -print0" + "Command used by projectile to get the files in a svn project." + :group 'projectile + :type 'string) + +(defcustom projectile-generic-command "find . -type f -print0" + "Command used by projectile to get the files in a generic project." + :group 'projectile + :type 'string) + +(defun projectile-get-ext-command () + "Determine which external command to invoke based on the project's VCS." + (let ((vcs (projectile-project-vcs))) + (cond + ((eq vcs 'git) projectile-git-command) + ((eq vcs 'hg) projectile-hg-command) + ((eq vcs 'fossil) projectile-fossil-command) + ((eq vcs 'bzr) projectile-bzr-command) + ((eq vcs 'darcs) projectile-darcs-command) + ((eq vcs 'svn) projectile-svn-command) + (t projectile-generic-command)))) + +(defun projectile-get-repo-files () + "Get a list of the files in the project." + (projectile-files-via-ext-command (projectile-get-ext-command))) + +(defun projectile-files-via-ext-command (command) + "Get a list of relative file names in the project root by executing COMMAND." + (split-string (shell-command-to-string command) "\0" t)) + +(defun projectile-index-directory (directory patterns) + "Index DIRECTORY taking into account PATTERNS. +The function calls itself recursively until all sub-directories +have been indexed." + (let (files-list) + (dolist (current-file (file-name-all-completions "" directory) files-list) + (let ((absolute-file (expand-file-name current-file directory))) + (cond + ;; check for directories that are not ignored + ((and (s-ends-with-p "/" current-file) + ;; avoid loops & ignore some well known directories + (not (-any? (lambda (file) + (string= (s-chop-suffix "/" current-file) file)) + '("." ".." ".svn" ".cvs"))) + (not (projectile-ignored-directory-p absolute-file)) + (not (and patterns + (projectile-ignored-rel-p directory + absolute-file patterns)))) + (setq files-list (append files-list + (projectile-index-directory + (expand-file-name current-file directory) + patterns)))) + ;; check for regular files that are not ignored + ((and (not (s-ends-with-p "/" current-file)) + (not (projectile-ignored-file-p absolute-file)) + (not (and patterns + (projectile-ignored-rel-p directory + absolute-file patterns)))) + (setq files-list (cons + (expand-file-name current-file directory) + files-list)))))))) + +(defun projectile-project-buffers () + "Get a list of project buffers." + (let ((project-root (projectile-project-root))) + (-filter (lambda (buffer) + (projectile-project-buffer-p buffer project-root)) + (buffer-list)))) + +(defun projectile-project-buffer-p (buffer project-root) + "Check if BUFFER is under PROJECT-ROOT." + (with-current-buffer buffer + (and (s-starts-with? project-root + (expand-file-name default-directory)) + ;; ignore hidden buffers + (not (s-starts-with? " " (buffer-name buffer)))))) + +(defun projectile-project-buffer-names () + "Get a list of project buffer names." + (-map 'buffer-name (projectile-project-buffers))) + +(defun projectile-prepend-project-name (string) + "Prepend the current project's name to STRING." + (format "[%s] %s" (projectile-project-name) string)) + +(defun projectile-switch-to-buffer () + "Switch to a project buffer." + (interactive) + (switch-to-buffer + (projectile-completing-read + "Switch to buffer: " + (projectile-project-buffer-names)))) + +(defun projectile-multi-occur () + "Do a `multi-occur' in the project's buffers." + (interactive) + (multi-occur (projectile-project-buffers) + (car (occur-read-primary-args)))) + +(defun projectile-ignored-directory-p (directory) + "Check if DIRECTORY should be ignored." + (member directory (projectile-ignored-directories))) + +(defun projectile-ignored-file-p (file) + "Check if FILE should be ignored." + (member file (projectile-ignored-files))) + +(defun projectile-ignored-rel-p (directory file patterns) + "Check if FILE should be ignored relative to DIRECTORY according to PATTERNS." + (let ((default-directory directory)) + (-any? (lambda (pattern) + (or (s-ends-with? (s-chop-suffix "/" pattern) + (s-chop-suffix "/" file)) + (member file (file-expand-wildcards pattern t)))) + patterns))) + +(defun projectile-ignored-files () + "Return list of ignored files." + (-map + 'projectile-expand-root + (append + projectile-globally-ignored-files + (projectile-project-ignored-files)))) + +(defun projectile-ignored-directories () + "Return list of ignored directories." + (-map + 'file-name-as-directory + (-map + 'projectile-expand-root + (append + projectile-globally-ignored-directories + (projectile-project-ignored-directories))))) + +(defun projectile-project-ignored-files () + "Return list of project ignored files." + (-remove 'file-directory-p (projectile-project-ignored))) + +(defun projectile-project-ignored-directories () + "Return list of project ignored directories." + (-filter 'file-directory-p (projectile-project-ignored))) + +(defun projectile-paths-to-ignore () + "Return a list of ignored project paths." + (-map (lambda (pattern) + (s-chop-prefix "/" pattern)) + (-filter (lambda (pattern) + (s-starts-with? "/" pattern)) + (cdr (projectile-parse-dirconfig-file))))) + +(defun projectile-patterns-to-ignore () + "Return a list of relative file patterns." + (-remove (lambda (pattern) + (s-starts-with? "/" pattern)) + (cdr (projectile-parse-dirconfig-file)))) + +(defun projectile-project-ignored () + "Return list of project ignored files/directories." + (let ((paths (projectile-paths-to-ignore)) + (default-directory (projectile-project-root))) + (apply 'append + (-map + (lambda (pattern) + (file-expand-wildcards pattern t)) + paths)))) + +(defun projectile-dirconfig-file () + "Return the absolute path to the project's dirconfig file." + (expand-file-name ".projectile" (projectile-project-root))) + +(defun projectile-parse-dirconfig-file () + "Parse project ignore file and return directories to ignore and keep. + +The return value will be a cons, the car being the list of +directories to keep, and the cdr being the list of files or +directories to ignore. + +Strings starting with + will be added to the list of directories +to keep, and strings starting with - will be added to the list of +directories to ignore. For backward compatibility, without a +prefix the string will be assumed to be an ignore string." + (let ((dirconfig-file (projectile-dirconfig-file))) + (when (file-exists-p dirconfig-file) + (with-temp-buffer + (insert-file-contents-literally dirconfig-file) + (let* ((split-string-default-separators "[\r\n]") + (strings (-map 's-trim (delete "" (split-string (buffer-string))))) + (separated-vals (--separate (s-starts-with? "+" it) strings))) + (flet ((strip-prefix (s) (s-chop-prefixes '("-" "+") s))) + (cons (-map 'strip-prefix (first separated-vals)) + (-map 'strip-prefix (second separated-vals))))))))) + +(defun projectile-expand-root (name) + "Expand NAME to project root. + +Never use on many files since it's going to recalculate the +project-root for every file." + (expand-file-name name (projectile-project-root))) + +(defun projectile-completing-read (prompt choices) + "Present a project tailored PROMPT with CHOICES." + (let ((prompt (projectile-prepend-project-name prompt))) + (cond + ((eq projectile-completion-system 'ido) + (ido-completing-read prompt choices)) + ((eq projectile-completion-system 'default) + (completing-read prompt choices)) + ((eq projectile-completion-system 'grizzl) + (if (and (fboundp 'grizzl-completing-read) + (fboundp 'grizzl-make-index)) + (grizzl-completing-read prompt (grizzl-make-index choices)) + (user-error "Please install grizzl from \ +https://github.com/d11wtq/grizzl"))) + (t (funcall projectile-completion-system prompt choices))))) + +(defun projectile-current-project-files () + "Return a list of files for the current project." + (let ((files (and projectile-enable-caching + (gethash (projectile-project-root) projectile-projects-cache)))) + ;; nothing is cached + (unless files + (setq files (-mapcat 'projectile-dir-files + (projectile-get-project-directories))) + ;; cache the resulting list of files + (when projectile-enable-caching + (projectile-cache-project (projectile-project-root) files))) + files)) + +(defun projectile-current-project-dirs () + "Return a list of dirs for the current project." + (-remove 'null (-distinct + (-map 'file-name-directory + (projectile-current-project-files))))) + +(defun projectile-hash-keys (hash) + "Return a list of all HASH keys." + (let (allkeys) + (maphash (lambda (k v) (setq allkeys (cons k allkeys))) hash) + allkeys)) + +(defun projectile-find-file (arg) + "Jump to a project's file using completion. + +With a prefix ARG invalidates the cache first." + (interactive "P") + (when arg + (projectile-invalidate-cache nil)) + (let ((file (projectile-completing-read "Find file: " + (projectile-current-project-files)))) + (find-file (expand-file-name file (projectile-project-root))) + (run-hooks 'projectile-find-file-hook))) + +(defun projectile-find-dir (arg) + "Jump to a project's file using completion. + +With a prefix ARG invalidates the cache first." + (interactive "P") + (when arg + (projectile-invalidate-cache nil)) + (let ((dir (projectile-completing-read "Find dir: " + (projectile-current-project-dirs)))) + (dired (expand-file-name dir (projectile-project-root))) + (run-hooks 'projectile-find-dir-hook))) + +(defun projectile-find-test-file (arg) + "Jump to a project's test file using completion. + +With a prefix ARG invalidates the cache first." + (interactive "P") + (when arg + (projectile-invalidate-cache nil)) + (let ((file (projectile-completing-read "Find test file: " + (projectile-current-project-files)))) + (find-file (expand-file-name file (projectile-project-root))))) + +(defvar projectile-test-files-suffices '("_test" "_spec" "Test" "-test") + "Some common suffices of test files.") + +(defun projectile-test-files (files) + "Return only the test FILES." + (-filter 'projectile-test-file-p files)) + +(defun projectile-test-file-p (file) + "Check if FILE is a test file." + (-any? (lambda (suffix) + (s-ends-with? suffix (file-name-sans-extension file))) + projectile-test-files-suffices)) + +(defvar projectile-rails-rspec '("Gemfile" "app" "lib" "db" "config" "spec")) +(defvar projectile-rails-test '("Gemfile" "app" "lib" "db" "config" "test")) +(defvar projectile-symfony '("composer.json" "app" "src" "vendor")) +(defvar projectile-ruby-rspec '("Gemfile" "lib" "spec")) +(defvar projectile-ruby-test '("Gemfile" "lib" "test")) +(defvar projectile-maven '("pom.xml")) +(defvar projectile-lein '("project.clj")) +(defvar projectile-rebar '("rebar")) +(defvar projectile-make '("Makefile")) + +(defun projectile-project-type () + "Determine the project's type based on its structure." + (let ((project-root (projectile-project-root))) + (cond + ((projectile-verify-files projectile-rails-rspec) 'rails-rspec) + ((projectile-verify-files projectile-rails-test) 'rails-test) + ((projectile-verify-files projectile-ruby-rspec) 'ruby-rspec) + ((projectile-verify-files projectile-ruby-test) 'ruby-test) + ((projectile-verify-files projectile-symfony) 'symfony) + ((projectile-verify-files projectile-maven) 'maven) + ((projectile-verify-files projectile-lein) 'lein) + ((projectile-verify-files projectile-rebar) 'rebar) + ((projectile-verify-files projectile-make) 'make) + (t 'generic)))) + +(defun projectile-verify-files (files) + "Check whether all FILES exist in the current project." + (-all? 'projectile-verify-file files)) + +(defun projectile-verify-file (file) + "Check whether FILE exists in the current project." + (file-exists-p (projectile-expand-root file))) + +(defun projectile-project-vcs () + "Determine the VCS used by the project if any." + (let ((project-root (projectile-project-root))) + (cond + ((file-exists-p (expand-file-name ".git" project-root)) 'git) + ((file-exists-p (expand-file-name ".hg" project-root)) 'hg) + ((file-exists-p (expand-file-name ".fossil" project-root)) 'fossil) + ((file-exists-p (expand-file-name ".bzr" project-root)) 'bzr) + ((file-exists-p (expand-file-name "_darcs" project-root)) 'darcs) + ((file-exists-p (expand-file-name ".svn" project-root)) 'svn) + ((locate-dominating-file project-root ".git") 'git) + ((locate-dominating-file project-root ".hg") 'hg) + ((locate-dominating-file project-root ".fossil") 'fossil) + ((locate-dominating-file project-root ".bzr") 'bzr) + ((locate-dominating-file project-root "_darcs") 'darcs) + ((locate-dominating-file project-root ".svn") 'svn) + (t 'none)))) + +(defun projectile-toggle-between-implemenation-and-test () + "Toggle between an implementation file and its test file." + (interactive) + (if (projectile-test-file-p (buffer-file-name)) + ;; find the matching impl file + (let ((impl-file (projectile-find-matching-file (buffer-file-name)))) + (if impl-file + (find-file (projectile-expand-root impl-file)) + (error "No matching source file found"))) + ;; find the matching test file + (let ((test-file (projectile-find-matching-test (buffer-file-name)))) + (if test-file + (find-file (projectile-expand-root test-file)) + (error "No matching test file found"))))) + +(defun projectile-test-suffix (project-type) + "Find test files suffix based on PROJECT-TYPE." + (cond + ((member project-type '(rails-rspec ruby-rspec)) "_spec") + ((member project-type '(rails-test ruby-test lein)) "_test") + ((member project-type '(maven symfony)) "Test") + (t (error "Project type not supported!")))) + +(defun projectile-find-matching-test (file) + "Compute the name of the test matching FILE." + (let ((basename (file-name-nondirectory (file-name-sans-extension file))) + (extension (file-name-extension file)) + (test-suffix (projectile-test-suffix (projectile-project-type)))) + (-first (lambda (current-file) + (s-equals? (file-name-nondirectory (file-name-sans-extension current-file)) + (concat basename test-suffix))) + (projectile-current-project-files)))) + +(defun projectile-find-matching-file (test-file) + "Compute the name of a file matching TEST-FILE." + (let ((basename (file-name-nondirectory (file-name-sans-extension test-file))) + (extension (file-name-extension test-file)) + (test-suffix (projectile-test-suffix (projectile-project-type)))) + (-first (lambda (current-file) + (s-equals? (concat (file-name-nondirectory (file-name-sans-extension current-file)) test-suffix) + basename)) + (projectile-current-project-files)))) + +(defun projectile-grep () + "Perform rgrep in the project." + (interactive) + (let ((roots (projectile-get-project-directories)) + (search-regexp (if (and transient-mark-mode mark-active) + (buffer-substring (region-beginning) (region-end)) + (read-string (projectile-prepend-project-name "Grep for: ") + (projectile-symbol-at-point))))) + (dolist (root-dir roots) + (require 'grep) + ;; paths for find-grep should relative and without trailing / + (let ((grep-find-ignored-directories (union (-map (lambda (dir) (s-chop-suffix "/" (s-chop-prefix root-dir dir))) + (cdr (projectile-ignored-directories))) grep-find-ignored-directories)) + (grep-find-ignored-files (union (-map (lambda (file) (s-chop-prefix root-dir file)) (projectile-ignored-files)) grep-find-ignored-files))) + (grep-compute-defaults) + (rgrep search-regexp "* .*" root-dir))))) + +(defun projectile-ack () + "Run an `ack-and-a-half' search in the project." + (interactive) + (let ((ack-and-a-half-arguments + (-map + (lambda (path) + (concat "--ignore-dir=" (file-name-nondirectory (directory-file-name path)))) + (projectile-ignored-directories)))) + (call-interactively projectile-ack-function))) + +(defun projectile-tags-exclude-patterns () + "Return a string with exclude patterns for ctags." + (mapconcat (lambda (pattern) (format "--exclude=%s" pattern)) + (projectile-project-ignored-directories) " ")) + +(defun projectile-regenerate-tags () + "Regenerate the project's etags." + (interactive) + (let* ((project-root (projectile-project-root)) + (tags-exclude (projectile-tags-exclude-patterns)) + (default-directory project-root)) + (shell-command (format projectile-tags-command tags-exclude project-root)) + (visit-tags-table project-root))) + +(defun projectile-replace () + "Replace a string in the project using `tags-query-replace'." + (interactive) + (let* ((old-text (read-string + (projectile-prepend-project-name "Replace: ") + (projectile-symbol-at-point))) + (new-text (read-string + (projectile-prepend-project-name + (format "Replace %s with: " old-text))))) + (tags-query-replace old-text new-text nil '(-map 'projectile-expand-root (projectile-current-project-files))))) + +(defun projectile-symbol-at-point () + "Get the symbol at point and strip its properties." + (substring-no-properties (or (thing-at-point 'symbol) ""))) + +(defun projectile-kill-buffers () + "Kill all project buffers." + (interactive) + (let* ((buffers (projectile-project-buffer-names)) + (question + (format + "Are you sure you want to kill %d buffer(s) for '%s'? " + (length buffers) + (projectile-project-name)))) + (if (yes-or-no-p question) + (mapc 'kill-buffer buffers)))) + +(defun projectile-dired () + "Opens dired at the root of the project." + (interactive) + (dired (projectile-project-root))) + +(defun projectile-recentf () + "Show a list of recently visited files in a project." + (interactive) + (if (boundp 'recentf-list) + (find-file (projectile-expand-root (projectile-completing-read "Recently visited files: " (projectile-recentf-files))))) + (message "recentf is not enabled")) + +(defun projectile-recentf-files () + "Return a list of recently visited files in a project." + (if (boundp 'recentf-list) + (let ((project-root (projectile-project-root))) + (->> recentf-list + (-filter (lambda (file) (s-starts-with-p project-root file))) + (-map (lambda (file) (s-chop-prefix project-root file))))) + nil)) + +(defun projectile-serialize-cache () + "Serializes the memory cache to the hard drive." + (projectile-serialize projectile-projects-cache projectile-cache-file)) + +(defvar projectile-rails-compile-cmd "bundle exec rails server") +(defvar projectile-ruby-compile-cmd "bundle exec rake build") +(defvar projectile-ruby-test-cmd "bundle exec rake test") +(defvar projectile-ruby-rspec-cmd "bundle exec rspec") +(defvar projectile-symfony-compile-cmd "app/console server:run") +(defvar projectile-symfony-test-cmd "phpunit -c app ") +(defvar projectile-maven-compile-cmd "mvn clean install") +(defvar projectile-maven-test-cmd "mvn test") +(defvar projectile-lein-compile-cmd "lein compile") +(defvar projectile-lein-test-cmd "lein test") +(defvar projectile-rebar-compile-cmd "rebar") +(defvar projectile-rebar-test-cmd "rebar eunit") +(defvar projectile-make-compile-cmd "make") +(defvar projectile-make-test-cmd "make test") + +(defvar projectile-compilation-cmd-map + (make-hash-table :test 'equal) + "A mapping between projects and the last compilation command used on them.") +(defvar projectile-test-cmd-map + (make-hash-table :test 'equal) + "A mapping between projects and the last test command used on them.") + +(defun projectile-default-compilation-command (project-type) + "Retrieve default compilation command for PROJECT-TYPE." + (cond + ((member project-type '(rails-rspec rails-test)) projectile-rails-compile-cmd) + ((member project-type '(ruby-rspec ruby-test)) projectile-ruby-compile-cmd) + ((eq project-type 'symfony) projectile-symfony-compile-cmd) + ((eq project-type 'lein) projectile-lein-compile-cmd) + ((eq project-type 'make) projectile-make-compile-cmd) + ((eq project-type 'rebar) projectile-rebar-compile-cmd) + ((eq project-type 'maven) projectile-maven-compile-cmd) + (t projectile-make-compile-cmd))) + +(defun projectile-default-test-command (project-type) + "Retrieve default test command for PROJECT-TYPE." + (cond + ((member project-type '(rails-rspec ruby-rspec)) projectile-ruby-rspec-cmd) + ((member project-type '(rails-test ruby-test)) projectile-ruby-test-cmd) + ((eq project-type 'symfony) projectile-symfony-test-cmd) + ((eq project-type 'lein) projectile-lein-test-cmd) + ((eq project-type 'make) projectile-make-test-cmd) + ((eq project-type 'rebar) projectile-rebar-test-cmd) + ((eq project-type 'maven) projectile-maven-test-cmd) + (t projectile-make-test-cmd))) + +(defun projectile-compilation-command (project) + "Retrieve the compilation command for PROJECT." + (or (gethash project projectile-compilation-cmd-map) + (projectile-default-compilation-command (projectile-project-type)))) + +(defun projectile-test-command (project) + "Retrieve the compilation command for PROJECT." + (or (gethash project projectile-test-cmd-map) + (projectile-default-test-command (projectile-project-type)))) + +(defun projectile-compile-project () + "Run project compilation command." + (interactive) + (let* ((project-root (projectile-project-root)) + (compilation-cmd (compilation-read-command (projectile-compilation-command project-root))) + (default-directory project-root)) + (puthash project-root compilation-cmd projectile-compilation-cmd-map) + (compilation-start compilation-cmd))) + +;; TODO - factor this duplication out +(defun projectile-test-project () + "Run project test command." + (interactive) + (let* ((project-root (projectile-project-root)) + (test-cmd (compilation-read-command (projectile-test-command project-root))) + (default-directory project-root)) + (puthash project-root test-cmd projectile-test-cmd-map) + (compilation-start test-cmd))) + +(defun projectile-switch-project () + "Switch to a project we have seen before." + (interactive) + (let* ((project-to-switch + (projectile-completing-read "Switch to which project: " + projectile-known-projects)) + (default-directory project-to-switch)) + (projectile-find-file nil) + (let ((project-switched project-to-switch)) + (run-hooks 'projectile-switch-project-hook)))) + +(defvar projectile-switch-project-hook nil + "Hooks run when project is switched. + +The path to the opened project is available as PROJECT-SWITCHED") + +(defun projectile-clear-known-projects () + "Clear both `projectile-known-projects' and `projectile-known-projects-file'." + (interactive) + (setq projectile-known-projects nil) + (projectile-save-known-projects)) + +(defun projectile-remove-known-project () + "Remove a projected from the list of known projects." + (interactive) + (let ((project-to-remove + (projectile-completing-read "Switch to which project: " + projectile-known-projects))) + (setq projectile-known-projects + (--reject (string= project-to-remove it) projectile-known-projects)) + (projectile-save-known-projects) + (message "Project %s removed from the list of known projects." project-to-remove))) + +(defun projectile-add-known-project (project-root) + "Add PROJECT-ROOT to the list of known projects." + (setq projectile-known-projects + (-distinct + (cons (abbreviate-file-name project-root) projectile-known-projects)))) + +(defun projectile-load-known-projects () + "Load saved projects from `projectile-known-projects-file'. +Also set `projectile-known-projects'." + (setq projectile-known-projects + (projectile-unserialize projectile-known-projects-file))) + +;; load the known projects +(projectile-load-known-projects) + +(defun projectile-save-known-projects () + "Save PROJECTILE-KNOWN-PROJECTS to PROJECTILE-KNOWN-PROJECTS-FILE." + (projectile-serialize projectile-known-projects projectile-known-projects-file)) + +(defvar projectile-mode-map + (let ((map (make-sparse-keymap))) + (let ((prefix-map (make-sparse-keymap))) + (define-key prefix-map (kbd "f") 'projectile-find-file) + (define-key prefix-map (kbd "T") 'projectile-find-test-file) + (define-key prefix-map (kbd "t") 'projectile-toggle-between-implemenation-and-test) + (define-key prefix-map (kbd "g") 'projectile-grep) + (define-key prefix-map (kbd "b") 'projectile-switch-to-buffer) + (define-key prefix-map (kbd "o") 'projectile-multi-occur) + (define-key prefix-map (kbd "r") 'projectile-replace) + (define-key prefix-map (kbd "i") 'projectile-invalidate-cache) + (define-key prefix-map (kbd "R") 'projectile-regenerate-tags) + (define-key prefix-map (kbd "k") 'projectile-kill-buffers) + (define-key prefix-map (kbd "d") 'projectile-find-dir) + (define-key prefix-map (kbd "D") 'projectile-dired) + (define-key prefix-map (kbd "e") 'projectile-recentf) + (define-key prefix-map (kbd "a") 'projectile-ack) + (define-key prefix-map (kbd "c") 'projectile-compile-project) + (define-key prefix-map (kbd "p") 'projectile-test-project) + (define-key prefix-map (kbd "z") 'projectile-cache-current-file) + (define-key prefix-map (kbd "s") 'projectile-switch-project) + + (define-key map projectile-keymap-prefix prefix-map)) + map) + "Keymap for Projectile mode.") + +(defun projectile-add-menu () + "Add Projectile's menu under Tools." + (easy-menu-add-item nil '("Tools") + '("Projectile" + ["Find file" projectile-find-file] + ["Switch to buffer" projectile-switch-to-buffer] + ["Kill project buffers" projectile-kill-buffers] + ["Recent files" projectile-recentf] + "--" + ["Open project in dired" projectile-dired] + ["Find in project (grep)" projectile-grep] + ["Find in project (ack)" projectile-ack] + ["Replace in project" projectile-replace] + ["Multi-occur in project" projectile-multi-occur] + "--" + ["Invalidate cache" projectile-invalidate-cache] + ["Regenerate etags" projectile-regenerate-tags] + "--" + ["Compile project" projectile-compile-project] + ["Test project" projectile-test-project] + "--" + ["About" projectile-version]) + "Search Files (Grep)...") + + (easy-menu-add-item nil '("Tools") '("--") "Search Files (Grep)...")) + +(defun projectile-remove-menu () + "Remove Projectile's menu." + (easy-menu-remove-item nil '("Tools") "Projectile") + (easy-menu-remove-item nil '("Tools") "--")) + +;;; define minor mode + +;;;###autoload +(define-minor-mode projectile-mode + "Minor mode to assist project management and navigation. + +\\{projectile-mode-map}" + :lighter " Projectile" + :keymap projectile-mode-map + :group 'projectile + (if projectile-mode + ;; on start + (projectile-add-menu) + ;; on stop + (projectile-remove-menu))) + +;;;###autoload +(define-globalized-minor-mode projectile-global-mode + projectile-mode + projectile-on) + +(defun projectile-on () + "Enable Projectile minor mode." + (projectile-mode 1)) + +(defun projectile-off () + "Disable Projectile minor mode." + (projectile-mode -1)) + +(defun projectile-global-on () + "Enable Projectile global minor mode." + (add-hook 'find-file-hook 'projectile-cache-files-find-file-hook) + (add-hook 'find-file-hook 'projectile-cache-projects-find-file-hook) + (add-hook 'projectile-find-dir-hook 'projectile-cache-projects-find-file-hook)) + +(defun projectile-global-off () + "Disable Projectile global minor mode." + (remove-hook 'find-file-hook 'projectile-cache-files-find-file-hook) + (remove-hook 'find-file-hook 'projectile-cache-projects-find-file-hook)) + +(defadvice projectile-global-mode (after projectile-setup-hooks activate) + "Add/remove `find-file-hook' functions within `projectile-global-mode'." + (if projectile-global-mode + (projectile-global-on) + (projectile-global-off))) + +(provide 'projectile) + +;; Local Variables: +;; byte-compile-warnings: (not cl-functions) +;; End: + +;;; projectile.el ends here diff --git a/emacs.d/elpa/projectile-0.9.2/projectile.elc b/emacs.d/elpa/projectile-0.9.2/projectile.elc new file mode 100644 index 0000000000000000000000000000000000000000..fd7f36f862afa78098c393a1427133eee0587a8c GIT binary patch literal 41745 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

w*g;DrDi5DB~$_PQ7wbSR%@^JB3? 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 AKL7v# literal 0 HcmV?d00001 diff --git a/emacs.d/elpa/s-1.6.1/s-autoloads.el b/emacs.d/elpa/s-1.6.1/s-autoloads.el new file mode 100644 index 0000000..c971a1d --- /dev/null +++ b/emacs.d/elpa/s-1.6.1/s-autoloads.el @@ -0,0 +1,18 @@ +;;; s-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads nil nil ("s-pkg.el" "s.el") (21002 9889 830403 +;;;;;; 0)) + +;;;*** + +(provide 's-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; s-autoloads.el ends here diff --git a/emacs.d/elpa/s-1.6.1/s-pkg.el b/emacs.d/elpa/s-1.6.1/s-pkg.el new file mode 100644 index 0000000..9dfc82e --- /dev/null +++ b/emacs.d/elpa/s-1.6.1/s-pkg.el @@ -0,0 +1 @@ +(define-package "s" "1.6.1" "The long lost Emacs string manipulation library." (quote nil)) diff --git a/emacs.d/elpa/s-1.6.1/s-pkg.elc b/emacs.d/elpa/s-1.6.1/s-pkg.elc new file mode 100644 index 0000000000000000000000000000000000000000..1c831c004696a59a79b30a0e472d6a91a7ce0a34 GIT binary patch literal 623 zcmbtR!A`?44Bfduz}4yrq%~bzgtqmT- zFYnoY<^E}RGn>t#vMga|yIyH2pgKe4WC$8fBdmGcju)RiBi~wkN?x30+H%xj4IBpv zo1uZMfW>m1uhw}6`64SO#@g8qYT|_S%}eLg-?S-{9dge^Ds_*kPcrtvGRpm_VNy>7 z%D{dE!8`p{B$wZ_f@M?fLxmPlQx|4S<;J1Hm|$G0eFiJd7vielRO#$-U3Gh zl>}|^kI45h9wa)gq=V2BFfT5;WW`l6HgIi3QFJS0t&B{1 +;; Version: 1.6.1 +;; Keywords: strings + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see . + +;;; Commentary: + +;; The long lost Emacs string manipulation library. +;; +;; See documentation on https://github.com/magnars/s.el#functions + +;;; Code: + +(defun s-trim-left (s) + "Remove whitespace at the beginning of S." + (if (string-match "\\`[ \t\n\r]+" s) + (replace-match "" t t s) + s)) + +(defun s-trim-right (s) + "Remove whitespace at the end of S." + (if (string-match "[ \t\n\r]+\\'" s) + (replace-match "" t t s) + s)) + +(defun s-trim (s) + "Remove whitespace at the beginning and end of S." + (s-trim-left (s-trim-right s))) + +(defun s-collapse-whitespace (s) + "Convert all adjacent whitespace characters to a single space." + (replace-regexp-in-string "[ \t\n\r]+" " " s)) + +(defun s-split (separator s &optional omit-nulls) + "Split S into substrings bounded by matches for regexp SEPARATOR. +If OMIT-NULLS is t, zero-length substrings are omitted. + +This is a simple wrapper around the built-in `split-string'." + (split-string s separator omit-nulls)) + +(defun s-lines (s) + "Splits S into a list of strings on newline characters." + (s-split "\\(\r\n\\|[\n\r]\\)" s)) + +(defun s-join (separator strings) + "Join all the strings in STRINGS with SEPARATOR in between." + (mapconcat 'identity strings separator)) + +(defun s-concat (&rest strings) + "Join all the string arguments into one string." + (apply 'concat strings)) + +(defun s-prepend (prefix s) + "Concatenate PREFIX and S." + (concat prefix s)) + +(defun s-append (suffix s) + "Concatenate S and SUFFIX." + (concat s suffix)) + +(defun s-repeat (num s) + "Make a string of S repeated NUM times." + (let (ss) + (while (> num 0) + (setq ss (cons s ss)) + (setq num (1- num))) + (apply 'concat ss))) + +(defun s-chop-suffix (suffix s) + "Remove SUFFIX if it is at end of S." + (let ((pos (- (length suffix)))) + (if (and (>= (length s) (length suffix)) + (string= suffix (substring s pos))) + (substring s 0 pos) + s))) + +(defun s-chop-suffixes (suffixes s) + "Remove SUFFIXES one by one in order, if they are at the end of S." + (while suffixes + (setq s (s-chop-suffix (car suffixes) s)) + (setq suffixes (cdr suffixes))) + s) + +(defun s-chop-prefix (prefix s) + "Remove PREFIX if it is at the start of S." + (let ((pos (length prefix))) + (if (and (>= (length s) (length prefix)) + (string= prefix (substring s 0 pos))) + (substring s pos) + s))) + +(defun s-chop-prefixes (prefixes s) + "Remove PREFIXES one by one in order, if they are at the start of S." + (while prefixes + (setq s (s-chop-prefix (car prefixes) s)) + (setq prefixes (cdr prefixes))) + s) + +(defun s-shared-start (s1 s2) + "Returns the longest prefix S1 and S2 have in common." + (let ((search-length (min (length s1) (length s2))) + (i 0)) + (while (and (< i search-length) + (= (aref s1 i) (aref s2 i))) + (setq i (1+ i))) + (substring s1 0 i))) + +(defun s-shared-end (s1 s2) + "Returns the longest suffix S1 and S2 have in common." + (let* ((l1 (length s1)) + (l2 (length s2)) + (search-length (min l1 l2)) + (i 0)) + (while (and (< i search-length) + (= (aref s1 (- l1 i 1)) (aref s2 (- l2 i 1)))) + (setq i (1+ i))) + ;; If I is 0, then it means that there's no common suffix between + ;; S1 and S2. + ;; + ;; However, since (substring s (- 0)) will return the whole + ;; string, `s-shared-end' should simply return the empty string + ;; when I is 0. + (if (zerop i) + "" + (substring s1 (- i))))) + +(defun s-chomp (s) + "Remove one trailing `\\n`, `\\r` or `\\r\\n` from S." + (s-chop-suffixes '("\n" "\r") s)) + +(defun s-truncate (len s) + "If S is longer than LEN, cut it down and add ... at the end." + (if (> (length s) len) + (format "%s..." (substring s 0 (- len 3))) + s)) + +(defun s-word-wrap (len s) + "If S is longer than LEN, wrap the words with newlines." + (with-temp-buffer + (insert s) + (let ((fill-column len)) + (fill-region (point-min) (point-max))) + (buffer-substring-no-properties (point-min) (point-max)))) + +(defun s-center (len s) + "If S is shorter than LEN, pad it with spaces so it is centered." + (let ((extra (max 0 (- len (length s))))) + (concat + (make-string (ceiling extra 2) ? ) + s + (make-string (floor extra 2) ? )))) + +(defun s-pad-left (len padding s) + "If S is shorter than LEN, pad it with PADDING on the left." + (let ((extra (max 0 (- len (length s))))) + (concat (make-string extra (string-to-char padding)) + s))) + +(defun s-pad-right (len padding s) + "If S is shorter than LEN, pad it with PADDING on the left." + (let ((extra (max 0 (- len (length s))))) + (concat s + (make-string extra (string-to-char padding))))) + +(defun s-left (len s) + "Returns up to the LEN first chars of S." + (if (> (length s) len) + (substring s 0 len) + s)) + +(defun s-right (len s) + "Returns up to the LEN last chars of S." + (let ((l (length s))) + (if (> l len) + (substring s (- l len) l) + s))) + +(defun s-ends-with? (suffix s &optional ignore-case) + "Does S end with SUFFIX? + +If IGNORE-CASE is non-nil, the comparison is done without paying +attention to case differences. + +Alias: `s-suffix?'" + (let ((start-pos (- (length s) (length suffix)))) + (and (>= start-pos 0) + (eq t (compare-strings suffix nil nil + s start-pos nil ignore-case))))) + +(defalias 's-ends-with-p 's-ends-with?) + +(defun s-starts-with? (prefix s &optional ignore-case) + "Does S start with PREFIX? + +If IGNORE-CASE is non-nil, the comparison is done without paying +attention to case differences. + +Alias: `s-prefix?'. This is a simple wrapper around the built-in +`string-prefix-p'." + (string-prefix-p prefix s ignore-case)) + +(defalias 's-starts-with-p 's-starts-with?) + +(defalias 's-suffix? 's-ends-with?) +(defalias 's-prefix? 's-starts-with?) +(defalias 's-suffix-p 's-ends-with?) +(defalias 's-prefix-p 's-starts-with?) + +(defun s--truthy? (val) + (not (null val))) + +(defun s-contains? (needle s &optional ignore-case) + "Does S contain NEEDLE? + +If IGNORE-CASE is non-nil, the comparison is done without paying +attention to case differences." + (let ((case-fold-search ignore-case)) + (s--truthy? (string-match-p (regexp-quote needle) s)))) + +(defalias 's-contains-p 's-contains?) + +(defun s-equals? (s1 s2) + "Is S1 equal to S2? + +This is a simple wrapper around the built-in `string-equal'." + (string-equal s1 s2)) + +(defalias 's-equals-p 's-equals?) + +(defun s-less? (s1 s2) + "Is S1 less than S2? + +This is a simple wrapper around the built-in `string-lessp'." + (string-lessp s1 s2)) + +(defalias 's-less-p 's-less?) + +(defun s-matches? (regexp s &optional start) + "Does REGEXP match S? +If START is non-nil the search starts at that index. + +This is a simple wrapper around the built-in `string-match-p'." + (s--truthy? (string-match-p regexp s start))) + +(defalias 's-matches-p 's-matches?) + +(defun s-blank? (s) + "Is S nil or the empty string?" + (or (null s) (string= "" s))) + +(defun s-lowercase? (s) + "Are all the letters in S in lower case?" + (let ((case-fold-search nil)) + (not (string-match-p "[[:upper:]]" s)))) + +(defun s-uppercase? (s) + "Are all the letters in S in upper case?" + (let ((case-fold-search nil)) + (not (string-match-p "[[:lower:]]" s)))) + +(defun s-mixedcase? (s) + "Are there both lower case and upper case letters in S?" + (let ((case-fold-search nil)) + (s--truthy? + (and (string-match-p "[[:lower:]]" s) + (string-match-p "[[:upper:]]" s))))) + +(defun s-capitalized? (s) + "In S, is the first letter upper case, and all other letters lower case?" + (let ((case-fold-search nil)) + (s--truthy? + (string-match-p "^[A-ZÆØÅ][^A-ZÆØÅ]*$" s)))) + +(defun s-numeric? (s) + "Is S a number?" + (s--truthy? + (string-match-p "^[0-9]+$" s))) + +(defun s-replace (old new s) + "Replaces OLD with NEW in S." + (replace-regexp-in-string (regexp-quote old) new s t t)) + +(defun s--aget (alist key) + (cdr (assoc key alist))) + +(defun s-replace-all (replacements s) + "REPLACEMENTS is a list of cons-cells. Each `car` is replaced with `cdr` in S." + (replace-regexp-in-string (regexp-opt (mapcar 'car replacements)) + (lambda (it) (s--aget replacements it)) + s)) + +(defun s-downcase (s) + "Convert S to lower case. + +This is a simple wrapper around the built-in `downcase'." + (downcase s)) + +(defun s-upcase (s) + "Convert S to upper case. + +This is a simple wrapper around the built-in `upcase'." + (upcase s)) + +(defun s-capitalize (s) + "Convert the first word's first character to upper case and the rest to lower case in S." + (concat (upcase (substring s 0 1)) (downcase (substring s 1)))) + +(defun s-titleize (s) + "Convert each word's first character to upper case and the rest to lower case in S. + +This is a simple wrapper around the built-in `capitalize'." + (capitalize s)) + +(defmacro s-with (s form &rest more) + "Threads S through the forms. Inserts S as the last item +in the first form, making a list of it if it is not a list +already. If there are more forms, inserts the first form as the +last item in second form, etc." + (if (null more) + (if (listp form) + `(,(car form) ,@(cdr form) ,s) + (list form s)) + `(s-with (s-with ,s ,form) ,@more))) + +(put 's-with 'lisp-indent-function 1) + +(defun s-index-of (needle s &optional ignore-case) + "Returns first index of NEEDLE in S, or nil. + +If IGNORE-CASE is non-nil, the comparison is done without paying +attention to case differences." + (let ((case-fold-search ignore-case)) + (string-match-p (regexp-quote needle) s))) + +(defun s-reverse (s) ;; from org-babel-reverse-string + "Return the reverse of S." + (apply 'string (nreverse (string-to-list s)))) + +(defun s-match-strings-all (regex string) + "Return a list of matches for REGEX in STRING. + +Each element itself is a list of matches, as per +`match-string'. Multiple matches at the same position will be +ignored after the first." + (let ((all-strings ()) + (i 0)) + (while (and (< i (length string)) + (string-match regex string i)) + (setq i (1+ (match-beginning 0))) + (let (strings + (num-matches (/ (length (match-data)) 2)) + (match 0)) + (while (/= match num-matches) + (push (match-string match string) strings) + (setq match (1+ match))) + (push (nreverse strings) all-strings))) + (nreverse all-strings))) + +(defun s-match (regexp s &optional start) + "When the given expression matches the string, this function returns a list +of the whole matching string and a string for each matched subexpressions. +If it did not match the returned value is an empty list (nil). + +When START is non-nil the search will start at that index." + (save-match-data + (if (string-match regexp s start) + (let ((match-data-list (match-data)) + result) + (while match-data-list + (let* ((beg (car match-data-list)) + (end (cadr match-data-list)) + (subs (if (and beg end) (substring s beg end) nil))) + (setq result (cons subs result)) + (setq match-data-list + (cddr match-data-list)))) + (nreverse result))))) + +(defun s-slice-at (regexp s) + "Slices S up at every index matching REGEXP." + (save-match-data + (let (i) + (setq i (string-match regexp s 1)) + (if i + (cons (substring s 0 i) + (s-slice-at regexp (substring s i))) + (list s))))) + +(defun s-split-words (s) + "Split S into list of words." + (s-split + "[^A-Za-z0-9]+" + (let ((case-fold-search nil)) + (replace-regexp-in-string "\\([a-z]\\)\\([A-Z]\\)" "\\1 \\2" s)) + t)) + +(defun s--mapcar-head (fn-head fn-rest list) + "Like MAPCAR, but applies a different function to the first element." + (if list + (cons (funcall fn-head (car list)) (mapcar fn-rest (cdr list))))) + +(defun s-lower-camel-case (s) + "Convert S to lowerCamelCase." + (s-join "" (s--mapcar-head 'downcase 'capitalize (s-split-words s)))) + +(defun s-upper-camel-case (s) + "Convert S to UpperCamelCase." + (s-join "" (mapcar 'capitalize (s-split-words s)))) + +(defun s-snake-case (s) + "Convert S to snake_case." + (s-join "_" (mapcar 'downcase (s-split-words s)))) + +(defun s-dashed-words (s) + "Convert S to dashed-words." + (s-join "-" (mapcar 'downcase (s-split-words s)))) + +(defun s-capitalized-words (s) + "Convert S to Capitalized Words." + (let ((words (s-split-words s))) + (s-join " " (cons (capitalize (car words)) (mapcar 'downcase (cdr words)))))) + +(defun s-titleized-words (s) + "Convert S to Titleized Words." + (s-join " " (mapcar 's-titleize (s-split-words s)))) + + +;; Errors for s-format +(progn + (put 's-format-resolve + 'error-conditions + '(error s-format s-format-resolve)) + (put 's-format-resolve + 'error-message + "Cannot resolve a template to values")) + +(defun s-format (template replacer &optional extra) + "Format TEMPLATE with the function REPLACER. + +REPLACER takes an argument of the format variable and optionally +an extra argument which is the EXTRA value from the call to +`s-format'. + +Several standard `s-format' helper functions are recognized and +adapted for this: + + (s-format \"${name}\" 'gethash hash-table) + (s-format \"${name}\" 'aget alist) + (s-format \"$0\" 'elt sequence) + +The REPLACER function may be used to do any other kind of +transformation." + (let ((saved-match-data (match-data))) + (unwind-protect + (replace-regexp-in-string + "\\$\\({\\([^}]+\\)}\\|[0-9]+\\)" + (lambda (md) + (let ((var + (let ((m (match-string 2 md))) + (if m m + (string-to-number (match-string 1 md))))) + (replacer-match-data (match-data))) + (unwind-protect + (let ((v + (cond + ((eq replacer 'gethash) + (funcall replacer var extra)) + ((eq replacer 'aget) + (funcall 's--aget extra var)) + ((eq replacer 'elt) + (funcall replacer extra var)) + (t + (set-match-data saved-match-data) + (if extra + (funcall replacer var extra) + (funcall replacer var)))))) + (if v v (signal 's-format-resolve md))) + (set-match-data replacer-match-data)))) template + ;; Need literal to make sure it works + t t) + (set-match-data saved-match-data)))) + +(defvar s-lex-value-as-lisp nil + "If `t' interpolate lisp values as lisp. + +`s-lex-format' inserts values with (format \"%S\").") + +(defun s-lex-fmt|expand (fmt) + "Expand FMT into lisp." + (list 's-format fmt (quote 'aget) + (append '(list) + (mapcar + (lambda (matches) + (list + 'cons + (cadr matches) + `(format + (if s-lex-value-as-lisp "%S" "%s") + ,(intern (cadr matches))))) + (s-match-strings-all "${\\([^}]+\\)}" fmt))))) + +(defmacro s-lex-format (format-str) + "`s-format` with the current environment. + +FORMAT-STR may use the `s-format' variable reference to refer to +any variable: + + (let ((x 1)) + (s-lex-format \"x is: ${x}\")) + +The values of the variables are interpolated with \"%s\" unless +the variable `s-lex-value-as-lisp' is `t' and then they are +interpolated with \"%S\"." + (s-lex-fmt|expand format-str)) + +(provide 's) +;;; s.el ends here diff --git a/emacs.d/elpa/s-1.6.1/s.elc b/emacs.d/elpa/s-1.6.1/s.elc new file mode 100644 index 0000000000000000000000000000000000000000..9c73d6141571ea2a2002541e031e7c7c42977138 GIT binary patch literal 16209 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