rc | Gitar

Create fix for Company-fuzzy bug

Apparently NOBODY on the interwebz seemed to have a bug like this, and so, nobody knew how to fix it. Related bugs in other projects and their general solutions also failed. So eventually I just tried a dirty hack and it works flawlessly again. I added the fixed file to the repo tracker and added a warning for future me so I never have to deal with this annoying shitstain ever again.

Author: Maarten Vangeneugden
Date: Sept. 15, 2024, 5:32 p.m.
Hash: 226ba1eacdfb635e5235eb8141724d5cb1ce2045
Parent: d8fd1df30e145c60dbe0ad775b5aca18398c064a
Modified files: company-fuzzy.el; init.el

company-fuzzy.el ¶

876 additions and 0 deletions.

View changes Hide changes

+	1
+	2	;; Copyright (C) 2019-2024 Shen, Jen-Chieh
+	3	;; Created date 2019-08-01 16:54:34
+	4	;; FIXED by Maarten Vangeneugden at 2024-09-15
+	5
+	6	;; Author: Shen, Jen-Chieh <jcs090218@gmail.com>
+	7	;; URL: https://github.com/jcs-elpa/company-fuzzy
+	8	;; Version: 1.4.0
+	9	;; Package-Requires: ((emacs "26.1") (company "0.8.12") (s "1.12.0") (ht "2.0"))
+	10	;; Keywords: matching auto-complete complete fuzzy
+	11
+	12	;; This file is NOT part of GNU Emacs.
+	13
+	14	;; This program is free software; you can redistribute it and/or modify
+	15	;; it under the terms of the GNU General Public License as published by
+	16	;; the Free Software Foundation, either version 3 of the License, or
+	17	;; (at your option) any later version.
+	18
+	19	;; This program is distributed in the hope that it will be useful,
+	20	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+	21	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	22	;; GNU General Public License for more details.
+	23
+	24	;; You should have received a copy of the GNU General Public License
+	25	;; along with this program. If not, see <https://www.gnu.org/licenses/>.
+	26
+	27	;;; Commentary:
+	28	;;
+	29	;; Fuzzy matching for `company-mode'.
+	30	;;
+	31
+	32	;;; Code:
+	33
+	34	(require 'cl-lib)
+	35	(require 'ffap)
+	36	(require 'subr-x)
+	37
+	38	(require 'company)
+	39	(require 'ht)
+	40	(require 's)
+	41
+	42	(defgroup company-fuzzy nil
+	43	"Fuzzy matching for `company-mode'."
+	44	:prefix "company-fuzzy-"
+	45	:group 'company
+	46	:link '(url-link :tag "Repository" "https://github.com/jcs-elpa/company-fuzzy"))
+	47
+	48	(defcustom company-fuzzy-sorting-backend 'alphabetic
+	49	"Type for sorting/scoring backend."
+	50	:type '(choice (const :tag "none" none)
+	51	(const :tag "alphabetic" alphabetic)
+	52	(const :tag "flex" flex)
+	53	(const :tag "flx" flx)
+	54	(const :tag "flx-rs" flx-rs)
+	55	(const :tag "flxy" flxy)
+	56	(const :tag "fuz-skim" fuz-skim)
+	57	(const :tag "fuz-clangd" fuz-clangd)
+	58	(const :tag "fuz-bin-skim" fuz-bin-skim)
+	59	(const :tag "fuz-bin-clangd" fuz-bin-clangd)
+	60	(const :tag "liquidmetal" liquidmetal)
+	61	(const :tag "sublime-fuzzy" sublime-fuzzy))
+	62	:group 'company-fuzzy)
+	63
+	64	(defcustom company-fuzzy-prefix-on-top t
+	65	"Have the matching prefix on top."
+	66	:type 'boolean
+	67	:group 'company-fuzzy)
+	68
+	69	(defcustom company-fuzzy-sorting-function nil
+	70	"Function that gives all candidates and let you do your own sorting."
+	71	:type '(choice (const :tag "None" nil)
+	72	function)
+	73	:group 'company-fuzzy)
+	74
+	75	(defcustom company-fuzzy-sorting-score-function nil
+	76	"Function that gives candidates with same score and let you do your own sorting."
+	77	:type '(choice (const :tag "None" nil)
+	78	function)
+	79	:group 'company-fuzzy)
+	80
+	81	(defcustom company-fuzzy-show-annotation t
+	82	"Show annotation from source."
+	83	:type 'boolean
+	84	:group 'company-fuzzy)
+	85
+	86	(defcustom company-fuzzy-annotation-format " <%s>"
+	87	"Annotation string format."
+	88	:type 'string
+	89	:group 'company-fuzzy)
+	90
+	91	(defcustom company-fuzzy-passthrough-backends nil
+	92	"List of backends that already are fuzzy, so no filtering of candidates is done."
+	93	:type 'list
+	94	:group 'company-fuzzy)
+	95
+	96	(defcustom company-fuzzy-trigger-symbols '("." "->")
+	97	"List of symbols that allow trigger company when there is no prefix."
+	98	:type 'list
+	99	:group 'company-fuzzy)
+	100
+	101	(defcustom company-fuzzy-completion-separator "[ \t\r\n]\\\|\\_<\\\|\\_>"
+	102	"Use to identify the completion unit."
+	103	:type 'string
+	104	:group 'company-fuzzy)
+	105
+	106	(defcustom company-fuzzy-reset-selection nil
+	107	"If non-nil, reset the selection to default."
+	108	:type 'boolean
+	109	:group 'company-fuzzy)
+	110
+	111	(defface company-fuzzy-annotation-face
+	112	'((t (:inherit company-tooltip-annotation)))
+	113	"Face for annotation."
+	114	:group 'company-fuzzy)
+	115
+	116	(defvar-local company-fuzzy--prefix ""
+	117	"Generic prefix.")
+	118
+	119	(defvar-local company-fuzzy--prefix-first ""
+	120	"Store generic prefix's first character for caching.")
+	121
+	122	(defvar-local company-fuzzy--backends nil
+	123	"Company fuzzy backends we are going to use.")
+	124
+	125	(defvar-local company-fuzzy--recorded-backends nil
+	126	"Record down company local backends in current buffer.")
+	127
+	128	(defvar-local company-fuzzy--is-trigger-prefix-p nil
+	129	"Flag to see if currently completion having a valid prefix.")
+	130
+	131	(defvar-local company-fuzzy--prefixes (make-hash-table :test 'equal)
+	132	"Map for each backend's prefix.")
+	133
+	134	(defvar-local company-fuzzy--candidates (make-hash-table :test 'equal)
+	135	"Map for each bakend's candidates.")
+	136
+	137	;;
+	138	;; (@* "External" )
+	139	;;
+	140
+	141	(declare-function flex-score "ext:flex.el")
+	142	(declare-function flx-score "ext:flx.el")
+	143	(declare-function flx-rs-score "ext:flx-rs.el")
+	144	(declare-function flx-rs-load-dyn "ext:flx-rs.el")
+	145
+	146	(declare-function flxy-score "ext:flxy.el")
+	147	(declare-function flxy-load-dyn "ext:flxy.el")
+	148
+	149	(declare-function fuz-calc-score-skim "ext:fuz.el")
+	150	(declare-function fuz-calc-score-clangd "ext:fuz.el")
+	151	(declare-function fuz-build-and-load-dymod "ext:fuz.el")
+	152
+	153	(declare-function fuz-bin-score-skim "ext:fuz-bin.el")
+	154	(declare-function fuz-bin-score-clangd "ext:fuz-bin.el")
+	155	(declare-function fuz-bin-load-dyn "ext:fuz-bin.el")
+	156
+	157	(declare-function liquidmetal-score "ext:liquidmetal.el")
+	158
+	159	(declare-function sublime-fuzzy-score "ext:sublime-fuzzy.el")
+	160	(declare-function sublime-fuzzy-load-dyn "ext:sublime-fuzzy.el")
+	161
+	162	(declare-function company-emmet--prefix "ext:company-emmet.el")
+	163
+	164	;;
+	165	;; (@* "Mode" )
+	166	;;
+	167
+	168	(defun company-fuzzy--init ()
+	169	"Initialize all sorting backends."
+	170	(cl-case company-fuzzy-sorting-backend
+	171	(`flex (require 'flex))
+	172	(`flx (require 'flx))
+	173	(`flx-rs (require 'flx-rs) (flx-rs-load-dyn))
+	174	(`flxy (require 'flxy) (flxy-load-dyn))
+	175	((or fuz-skim fuz-clangd)
+	176	(require 'fuz)
+	177	(unless (require 'fuz-core nil t) (fuz-build-and-load-dymod)))
+	178	((or fuz-bin-skim fuz-bin-clangd)
+	179	(require 'fuz-bin) (fuz-bin-load-dyn))
+	180	(`liquidmetal (require 'liquidmetal))
+	181	(`sublime-fuzzy (require 'sublime-fuzzy) (sublime-fuzzy-load-dyn))))
+	182
+	183	(defun company-fuzzy--enable ()
+	184	"Record down all other backend to `company-fuzzy--backends'."
+	185	(company-fuzzy--init)
+	186	;; XXX Don't know why, but you need to clear it first to make local
+	187	;; variables work!
+	188	(ht-clear company-fuzzy--prefixes)
+	189	(ht-clear company-fuzzy--candidates)
+	190	(unless company-fuzzy--recorded-backends
+	191	(setq company-fuzzy--recorded-backends company-backends
+	192	company-fuzzy--backends (company-fuzzy--normalize-backend-list company-fuzzy--recorded-backends))
+	193	(setq-local company-backends '(company-fuzzy-all-other-backends))
+	194	(setq-local company-transformers (append company-transformers '(company-fuzzy--sort-candidates)))
+	195	(advice-add 'company--insert-candidate :before #'company-fuzzy--insert-candidate)
+	196	(advice-add 'company-yasnippet--completions-for-prefix :around #'company-fuzzy-yasnippet--completions-for-prefix))
+	197	(add-hook 'lsp-completion-mode-hook #'company-fuzzy--lsp-after-enabled nil t)
+	198	(add-hook 'eglot-managed-mode-hook #'company-fuzzy--lsp-after-enabled nil t))
+	199
+	200	(defun company-fuzzy--disable ()
+	201	"Revert all other backend back to `company-backends'."
+	202	(when company-fuzzy--recorded-backends
+	203	(setq-local company-backends company-fuzzy--recorded-backends)
+	204	(setq-local company-transformers (delq 'company-fuzzy--sort-candidates company-transformers))
+	205	(setq company-fuzzy--recorded-backends nil
+	206	company-fuzzy--backends nil)
+	207	(advice-remove 'company--insert-candidate #'company-fuzzy--insert-candidate)
+	208	(advice-remove 'company-yasnippet--completions-for-prefix #'company-fuzzy-yasnippet--completions-for-prefix))
+	209	(remove-hook 'lsp-completion-mode-hook #'company-fuzzy--lsp-after-enabled t)
+	210	(remove-hook 'eglot-managed-mode-hook #'company-fuzzy--lsp-after-enabled t))
+	211
+	212	;;;###autoload
+	213	(define-minor-mode company-fuzzy-mode
+	214	"Minor mode `company-fuzzy-mode'."
+	215	:lighter " ComFuz"
+	216	:group company-fuzzy
+	217	(if company-fuzzy-mode (company-fuzzy--enable) (company-fuzzy--disable)))
+	218
+	219	(defun company-fuzzy-turn-on-company-fuzzy-mode ()
+	220	"Turn on the `company-fuzzy-mode'."
+	221	(company-fuzzy-mode 1))
+	222
+	223	;;;###autoload
+	224	(define-globalized-minor-mode global-company-fuzzy-mode
+	225	company-fuzzy-mode company-fuzzy-turn-on-company-fuzzy-mode
+	226	:group 'company-fuzzy
+	227	:require 'company-fuzzy)
+	228
+	229	;;
+	230	;; (@* "Utilies" )
+	231	;;
+	232
+	233	(defun company-fuzzy--valid-candidates-p (candidates)
+	234	"Return non-nil if CANDIDATES is list of valid candidates."
+	235	(ignore-errors (stringp (nth 0 candidates))))
+	236
+	237	(defun company-fuzzy--async-candidates-p (candidates)
+	238	"Return non-nil if CANDIDATES is in async format."
+	239	(when (consp candidates)
+	240	(and (eq (car candidates) :async) (functionp (cdr candidates)))))
+	241
+	242	(defun company-fuzzy--symbol-start ()
+	243	"Return symbol start point from current cursor position."
+	244	(ignore-errors
+	245	(save-excursion
+	246	(forward-char -1)
+	247	(re-search-backward company-fuzzy-completion-separator)
+	248	(point))))
+	249
+	250	(defun company-fuzzy--furthest-prefix ()
+	251	"Return the possible furthest (greatest length) prefix."
+	252	(ht-clear company-fuzzy--prefixes)
+	253	(let ((final-len 0) final-prefix)
+	254	(dolist (backend company-fuzzy--backends)
+	255	(when-let ((prefix (ignore-errors (funcall backend 'prefix))))
+	256	(ht-set company-fuzzy--prefixes backend prefix)
+	257	(when-let* ((len (length prefix))
+	258	((< final-len len)))
+	259	(setq final-prefix prefix
+	260	final-len len))))
+	261	final-prefix))
+	262
+	263	(defun company-fuzzy--generic-prefix ()
+	264	"Return the most generic prefix."
+	265	(let ((start (company-fuzzy--symbol-start)))
+	266	(ignore-errors
+	267	(string-trim (buffer-substring-no-properties (or start (point-min)) (point))))))
+	268
+	269	(defun company-fuzzy--trigger-prefix-p ()
+	270	"Check if current prefix a trigger prefix."
+	271	(member company-fuzzy--prefix company-fuzzy-trigger-symbols))
+	272
+	273	(defun company-fuzzy--string-match (regexp string &optional start)
+	274	"Safe way to execute function `string-match'.
+	275	See function `string-match' for arguments REGEXP, STRING and START."
+	276	(or (ignore-errors (string-match regexp string start))
+	277	(ignore-errors (string-match (regexp-quote regexp) string start))))
+	278
+	279	(defun company-fuzzy--string-match-p (regexp string &optional start)
+	280	"Safe way to execute function `string-match-p'.
+	281	See function `string-match-p' for arguments REGEXP, STRING and START."
+	282	(or (ignore-errors (string-match-p regexp string start))
+	283	(ignore-errors (string-match-p (regexp-quote regexp) string start))))
+	284
+	285	(defun company-fuzzy--string-prefix-p (prefix string &optional ignore-case)
+	286	"Safe way to execute function `string-prefix-p'.
+	287	See function `string-prefix-p' for arguments PREFIX, STRING and IGNORE-CASE."
+	288	(ignore-errors (string-prefix-p prefix string ignore-case)))
+	289
+	290	(defun company-fuzzy--normalize-backend-list (backends)
+	291	"Normalize all BACKENDS as list."
+	292	(let (result-lst)
+	293	(dolist (backend backends)
+	294	(if (listp backend)
+	295	(let ((index 0))
+	296	(dolist (back backend)
+	297	(when (company-fuzzy--string-prefix-p "company-" (symbol-name back))
+	298	(push (nth index backend) result-lst))
+	299	(setq index (1+ index))))
+	300	(push backend result-lst)))
+	301	(setq result-lst (reverse result-lst))
+	302	(cl-remove-duplicates result-lst)))
+	303
+	304	(defun company-fuzzy--get-backend-by-candidate (candidate)
+	305	"Return the backend symbol by using CANDIDATE as search index."
+	306	(let ((match (ht-find (lambda (_backend cands)
+	307	(member candidate cands))
+	308	company-fuzzy--candidates)))
+	309	(car match)))
+	310
+	311	(defun company-fuzzy--call-backend (backend command key)
+	312	"Safely call BACKEND by COMMAND and KEY."
+	313	(ignore-errors (funcall backend command key)))
+	314
+	315	(defun company-fuzzy--backend-command (candidate command)
+	316	"Find the backend from the CANDIDATE then call the COMMAND."
+	317	(unless (string-empty-p candidate)
+	318	(when-let ((backend (company-fuzzy--get-backend-by-candidate candidate)))
+	319	(company-fuzzy--call-backend backend command candidate))))
+	320
+	321	;;
+	322	;; (@* "Annotation" )
+	323	;;
+	324
+	325	(defun company-fuzzy--get-backend-string (backend)
+	326	"Get BACKEND's as a string."
+	327	(if backend
+	328	(let ((name (symbol-name backend)))
+	329	(setq name (s-replace "company-" "" name)
+	330	name (s-replace "-company" "" name))
+	331	name)
+	332	""))
+	333
+	334	(defun company-fuzzy--backend-string (candidate backend)
+	335	"Form the BACKEND string by CANDIDATE."
+	336	(if (and company-fuzzy-show-annotation candidate)
+	337	(let ((backend-str (company-fuzzy--get-backend-string backend)))
+	338	(when (string-empty-p backend-str) (setq backend-str "unknown"))
+	339	(propertize
+	340	(format company-fuzzy-annotation-format backend-str)
+	341	'face 'company-fuzzy-annotation-face))
+	342	""))
+	343
+	344	(defun company-fuzzy--source-anno-string (candidate backend)
+	345	"Return the source annotation string by CANDIDATE and BACKEND."
+	346	(if (and candidate backend)
+	347	(company-fuzzy--call-backend backend 'annotation candidate)
+	348	""))
+	349
+	350	(defun company-fuzzy--extract-annotation (candidate)
+	351	"Extract annotation from CANDIDATE."
+	352	(let* ((backend (company-fuzzy--get-backend-by-candidate candidate))
+	353	(backend-str (company-fuzzy--backend-string candidate backend))
+	354	(orig-anno (company-fuzzy--source-anno-string candidate backend)))
+	355	(concat orig-anno backend-str)))
+	356
+	357	;;
+	358	;; (@* "Highlighting" )
+	359	;;
+	360
+	361	(defun company-fuzzy--pre-render (str &optional annotation-p)
+	362	"Prerender color with STR and flag ANNOTATION-P."
+	363	(unless annotation-p
+	364	(let* ((str-len (length str))
+	365	(prefix (company-fuzzy--backend-prefix-candidate str 'match))
+	366	(prefix (company-fuzzy--validate-prefix prefix))
+	367	(selection (or company-selection 0))
+	368	(cur-selection (nth selection company-candidates))
+	369	(splitted-section (remove "" (split-string str " ")))
+	370	(process-selection (nth 0 splitted-section))
+	371	(selected (string= cur-selection process-selection))
+	372	(selected-face (if selected
+	373	'company-tooltip-common-selection
+	374	'company-tooltip-common))
+	375	(selected-common-face (if selected
+	376	'company-tooltip-selection
+	377	'company-tooltip))
+	378	(splitted-c (remove "" (split-string prefix ""))))
+	379	(set-text-properties 0 str-len nil str)
+	380	(font-lock-prepend-text-property 0 str-len 'face selected-common-face str)
+	381	(dolist (c splitted-c)
+	382	(let ((pos (company-fuzzy--string-match-p (regexp-quote c) str)))
+	383	(while (and (numberp pos) (< pos str-len))
+	384	(font-lock-prepend-text-property pos (1+ pos) 'face selected-face str)
+	385	(setq pos (company-fuzzy--string-match-p (regexp-quote c) str (1+ pos))))))))
+	386	str)
+	387
+	388	;;
+	389	;; (@* "Sorting / Scoring" )
+	390	;;
+	391
+	392	(defun company-fuzzy--sort-prefix-on-top (candidates)
+	393	"Sort CANDIDATES that match prefix on top of all other selection."
+	394	(let (prefix-matches prefix)
+	395	(dolist (cand candidates)
+	396	(setq prefix (company-fuzzy--backend-prefix-candidate cand 'match)
+	397	prefix (company-fuzzy--validate-prefix prefix))
+	398	(when (company-fuzzy--string-prefix-p prefix cand)
+	399	(push cand prefix-matches)
+	400	(setq candidates (remove cand candidates))))
+	401	(setq prefix-matches (sort prefix-matches #'string-lessp)
+	402	candidates (append prefix-matches candidates)))
+	403	candidates)
+	404
+	405	(defun company-fuzzy--sort-candidates-by-function (candidates fnc &optional flip)
+	406	"Sort CANDIDATES with function call FNC.
+	407
+	408	If optional argument FLIP is non-nil, reverse query and pattern order."
+	409	(let ((scoring-table (make-hash-table :test 'equal)) scoring-keys)
+	410	(dolist (cand candidates)
+	411	(when-let* ((prefix (company-fuzzy--backend-prefix-candidate cand 'match))
+	412	(scoring (or (equal prefix 'anything)
+	413	(ignore-errors
+	414	(if flip (funcall fnc prefix cand)
+	415	(funcall fnc cand prefix)))))
+	416	(score (cond ((listp scoring) (nth 0 scoring))
+	417	((vectorp scoring) (aref scoring 0))
+	418	((numberp scoring) scoring)
+	419	(t 0))))
+	420	(ht-set scoring-table score (push cand (ht-get scoring-table score)))))
+	421	;; Get all keys, and turn into a list.
+	422	(ht-map (lambda (score-key _cands) (push score-key scoring-keys)) scoring-table)
+	423	(setq scoring-keys (sort scoring-keys #'>) ; Sort keys in order.
+	424	candidates nil) ; Clean up, and ready for final output.
+	425	(dolist (key scoring-keys)
+	426	(let ((cands (ht-get scoring-table key)))
+	427	(setq cands (reverse cands)) ; Respect to backend order.
+	428	(when (functionp company-fuzzy-sorting-score-function)
+	429	(setq cands (funcall company-fuzzy-sorting-score-function cands)))
+	430	(setq candidates (append candidates cands)))))
+	431	candidates)
+	432
+	433	(defun company-fuzzy--sort-candidates (candidates)
+	434	"Sort all CANDIDATES base on type of sorting backend."
+	435	;; IMPORTANT: Since the command `candidates' will change by `company-mode',
+	436	;; we manually set the candidates here so we get can consistent result.
+	437	(setq candidates (company-fuzzy--ht-all-candidates))
+	438	(when company-fuzzy-reset-selection
+	439	(setq company-selection company-selection-default))
+	440	;; Don't score when it start fresh, e.g. completing a function name in Java
+	441	;; with the . (dot) symbol
+	442	(unless company-fuzzy--is-trigger-prefix-p
+	443	(setq candidates
+	444	(cl-case company-fuzzy-sorting-backend
+	445	(`none candidates)
+	446	(`alphabetic (sort candidates #'string-lessp))
+	447	(`flex
+	448	(company-fuzzy--sort-candidates-by-function candidates #'flex-score))
+	449	(`flx
+	450	(company-fuzzy--sort-candidates-by-function candidates #'flx-score))
+	451	(`flx-rs
+	452	(company-fuzzy--sort-candidates-by-function candidates #'flx-rs-score))
+	453	(`flxy
+	454	(company-fuzzy--sort-candidates-by-function candidates #'flxy-score))
+	455	((or fuz-skim fuz-clangd)
+	456	(company-fuzzy--sort-candidates-by-function
+	457	candidates (if (eq company-fuzzy-sorting-backend 'fuz-skim)
+	458	#'fuz-calc-score-skim
+	459	#'fuz-calc-score-clangd)
+	460	t))
+	461	((or fuz-bin-skim fuz-bin-clangd)
+	462	(company-fuzzy--sort-candidates-by-function
+	463	candidates (if (eq company-fuzzy-sorting-backend 'fuz-bin-skim)
+	464	'fuz-bin-score-skim
+	465	'fuz-bin-score-clangd)
+	466	t))
+	467	(`liquidmetal
+	468	(company-fuzzy--sort-candidates-by-function candidates #'liquidmetal-score))
+	469	(`sublime-fuzzy
+	470	(company-fuzzy--sort-candidates-by-function candidates #'sublime-fuzzy-score t))))
+	471	(when company-fuzzy-prefix-on-top
+	472	(setq candidates (company-fuzzy--sort-prefix-on-top candidates)))
+	473	(when (functionp company-fuzzy-sorting-function)
+	474	(setq candidates (funcall company-fuzzy-sorting-function candidates))))
+	475	candidates)
+	476
+	477	;;
+	478	;; (@* "Completion" )
+	479	;;
+	480
+	481	;; ZEG WEET GE WAAROM IK DIE tfuuiyf HEB TOEGEVOEGD??
+	482	;; OMDAT DEZE KAKFUNCTIE DAN INEENS GEFIKST IS WAUW
+	483	(defun company-fuzzy--insert-candidate (candidate tfuuiyf)
+	484	"Insertion for CANDIDATE."
+	485	(when company-fuzzy-mode
+	486	;; NOTE: Here we force to change `company-prefix' so the completion
+	487	;; will do what we expected.
+	488	(let ((backend (company-fuzzy--get-backend-by-candidate candidate)))
+	489	(setq company-prefix (company-fuzzy--backend-prefix backend 'complete)))))
+	490
+	491	;;
+	492	;; (@* "Prefix" )
+	493	;;
+	494
+	495	(defun company-fuzzy--valid-prefix (backend)
+	496	"Guess the current BACKEND prefix."
+	497	(let ((prefix (ht-get company-fuzzy--prefixes backend)))
+	498	(if (stringp prefix) prefix
+	499	(thing-at-point 'symbol)))) ; Fallback
+	500
+	501	(defun company-fuzzy--validate-prefix (prefix)
+	502	"Validate the PREFIX to proper string."
+	503	(if (stringp prefix) ; this will handle 'anything symbol type
+	504	prefix ""))
+	505
+	506	(defun company-fuzzy--backend-prefix-complete (backend)
+	507	"Return prefix for each BACKEND while doing completion.
+	508
+	509	This function is use when function `company-fuzzy--insert-candidate' is
+	510	called. It returns the current selection prefix to prevent completion
+	511	completes in an odd way."
+	512	(cl-case backend
+	513	(`company-paths (company-fuzzy--valid-prefix backend))
+	514	(t (company-fuzzy--backend-prefix backend 'filter))))
+	515
+	516	(defun company-fuzzy--backend-prefix-filter (backend)
+	517	"Return prefix for each BACKEND while doing the first basic filerting.
+	518
+	519	This is some what the opposite to function `company-fuzzy--backend-prefix-get'
+	520	since it's try get as much candidates as possible, but this function returns
+	521	a prefix that can filter out some obvious impossible candidates."
+	522	(cl-case backend
+	523	(`company-capf (let* ((prefix (company-fuzzy--backend-prefix backend 'match))
+	524	(prefix (company-fuzzy--validate-prefix prefix)))
+	525	prefix))
+	526	(`company-files (company-fuzzy--valid-prefix backend))
+	527	(`company-paths (company-fuzzy--backend-prefix 'company-files 'match))
+	528	(t (company-fuzzy--backend-prefix backend 'match))))
+	529
+	530	(defun company-fuzzy--backend-prefix-match (backend)
+	531	"Return prefix for each BACKEND while matching candidates.
+	532
+	533	This function is use for scoring and matching algorithm. It returns a prefix
+	534	that best describe the current possible candidate.
+	535
+	536	For instance, if there is a candidate function `buffer-file-name' and with
+	537	current prefix `bfn'. It will just return `bfn' because the current prefix
+	538	does best describe the for this candidate."
+	539	(cl-case backend
+	540	((company-capf) (or (company-fuzzy--valid-prefix backend)
+	541	'anything))
+	542	(`company-c-headers
+	543	(when-let ((prefix (ht-get company-fuzzy--prefixes backend)))
+	544	;; Skip the first < or " symbol
+	545	(substring prefix 1 (length prefix))))
+	546	(`company-files
+	547	;; NOTE: For `company-files', we will return the last section of the path
+	548	;; for the best match.
+	549	;;
+	550	;; Example, if I have path `/path/to/dir'; then it shall return `dir'.
+	551	(when-let* ((prefix (ht-get company-fuzzy--prefixes backend))
+	552	(splitted (split-string prefix "/" t))
+	553	(len-splitted (length splitted))
+	554	(last (nth (1- len-splitted) splitted)))
+	555	last))
+	556	(`company-paths
+	557	(when-let ((prefix (ht-get company-fuzzy--prefixes backend)))
+	558	(if (string-suffix-p "/" prefix) 'anything
+	559	(nth 0 (last (split-string prefix "/" t))))))
+	560	(t company-fuzzy--prefix)))
+	561
+	562	(defun company-fuzzy--backend-prefix-get (backend)
+	563	"Return prefix for each BACKEND while getting candidates.
+	564
+	565	This function is use for simplify prefix, in order to get as much candidates
+	566	as possible for fuzzy work.
+	567
+	568	For instance, if I have prefix `bfn'; then most BACKEND will not return
+	569	function `buffer-file-name' as candidate. But with this function will use a
+	570	letter `b' instead of full prefix `bfn'. So the BACKEND will return something
+	571	that may be relavent to the first character `b'.
+	572
+	573	P.S. Not all backend work this way."
+	574	(cl-case backend
+	575	(`company-c-headers
+	576	;; Skip the < or " symbol for the first character
+	577	(ignore-errors (substring (ht-get company-fuzzy--prefixes backend) 1 2)))
+	578	(`company-files
+	579	(when-let ((prefix (ht-get company-fuzzy--prefixes backend)))
+	580	(let* ((splitted (split-string prefix "/" t))
+	581	(len-splitted (length splitted))
+	582	(last (nth (1- len-splitted) splitted))
+	583	(new-prefix prefix))
+	584	(when (< 1 len-splitted)
+	585	(setq new-prefix
+	586	(substring prefix 0 (- (length prefix) (length last)))))
+	587	new-prefix)))
+	588	(`company-paths
+	589	(when-let ((prefix (ht-get company-fuzzy--prefixes backend)))
+	590	(if (string-suffix-p "/" prefix) prefix
+	591	(file-name-directory prefix))))
+	592	(`company-emmet (company-emmet--prefix))
+	593	(t
+	594	;; Return an empty string or first character is likely going to return a
+	595	;; full list of candaidates. And this is what we want.
+	596	(when (ht-get company-fuzzy--prefixes backend)
+	597	company-fuzzy--prefix-first))))
+	598
+	599	(defun company-fuzzy--backend-prefix-candidate (cand type)
+	600	"Get the backend prefix by CAND and TYPE."
+	601	(let ((backend (company-fuzzy--get-backend-by-candidate cand)))
+	602	(company-fuzzy--backend-prefix backend type)))
+	603
+	604	(defun company-fuzzy--backend-prefix (backend type)
+	605	"Get the BACKEND prefix by TYPE."
+	606	(cl-case type
+	607	(`complete (company-fuzzy--backend-prefix-complete backend))
+	608	(`filter (company-fuzzy--backend-prefix-filter backend))
+	609	(`match (company-fuzzy--backend-prefix-match backend))
+	610	(`get (company-fuzzy--backend-prefix-get backend))))
+	611
+	612	;;
+	613	;; (@* "Fuzzy Matching" )
+	614	;;
+	615
+	616	(defun company-fuzzy--trim-trailing-re (regex)
+	617	"Trim incomplete REGEX.
+	618	If REGEX ends with \\\|, trim it, since then it matches an empty string."
+	619	(if (company-fuzzy--string-match "\\`\$.*\$[\\]\|\\'" regex) (match-string 1 regex) regex))
+	620
+	621	(defun company-fuzzy--regex-fuzzy (str)
+	622	"Build a regex sequence from STR.
+	623	Insert .* between each char."
+	624	(setq str (company-fuzzy--trim-trailing-re str))
+	625	(if (company-fuzzy--string-match "\\`\$\\^?\$\$.*?\$\$\\$?\$\\'" str)
+	626	(concat (match-string 1 str)
+	627	(let ((lst (string-to-list (match-string 2 str))))
+	628	(apply #'concat
+	629	(cl-mapcar
+	630	#'concat
+	631	(cons "" (cdr (mapcar (lambda (c) (format "[^%c\n]*" c))
+	632	lst)))
+	633	(mapcar (lambda (x) (format "\$%s\$" (regexp-quote (char-to-string x))))
+	634	lst))))
+	635	(match-string 3 str))
+	636	str))
+	637
+	638	(defun company-fuzzy--match-string (prefix candidates)
+	639	"Return new CANDIDATES that match PREFIX."
+	640	(when (stringp prefix)
+	641	(let ((fuz-str (company-fuzzy--regex-fuzzy prefix)) new-cands)
+	642	(dolist (cand candidates)
+	643	(when (company-fuzzy--string-match-p fuz-str cand)
+	644	(push cand new-cands)))
+	645	new-cands)))
+	646
+	647	;;
+	648	;; (@* "Core" )
+	649	;;
+	650
+	651	(defun company-fuzzy--ht-all-candidates ()
+	652	"Return all candidates from the data."
+	653	(let (all-candidates)
+	654	(ht-map (lambda (_backend cands)
+	655	(setq all-candidates (append all-candidates cands)))
+	656	company-fuzzy--candidates)
+	657	(delete-dups all-candidates)))
+	658
+	659	(defun company-fuzzy-all-candidates ()
+	660	"Return the list of all candidates."
+	661	(ht-clear company-fuzzy--candidates) ; Clean up
+	662	(setq company-fuzzy--is-trigger-prefix-p (company-fuzzy--trigger-prefix-p))
+	663	(dolist (backend company-fuzzy--backends)
+	664	(if (or (company-fuzzy--lsp-passthrough backend)
+	665	(memq backend company-fuzzy-passthrough-backends))
+	666	(company-fuzzy--candidates-from-passthrough-backend backend)
+	667	(company-fuzzy--candidates-from-backend backend)))
+	668	;; Since we insert the candidates before sorting event, see function
+	669	;; `company-fuzzy--sort-candidates', we return to simply avoid the process
+	670	;; from `company-mode'.
+	671	;;
+	672	;; This should help us save some performance!
+	673	(when (eq this-command 'company-diag)
+	674	;; We did return candidates here, yet this does not mean `company-diag'
+	675	;; will respect this result.
+	676	(company-fuzzy--ht-all-candidates)))
+	677
+	678	(defun company-fuzzy--candidates-from-passthrough-backend (backend)
+	679	"Use candidates of already fuzzy BACKEND as is."
+	680	(let ((prefix-get (company-fuzzy--backend-prefix backend 'get))
+	681	temp-candidates)
+	682	(when prefix-get
+	683	(setq temp-candidates (company-fuzzy--call-backend backend 'candidates prefix-get)))
+	684	(company-fuzzy--collect-candidates backend temp-candidates)))
+	685
+	686	(defun company-fuzzy--candidates-from-backend (backend)
+	687	"Do fuzzy matching for current BACKEND."
+	688	(let ((prefix-get (company-fuzzy--backend-prefix backend 'get))
+	689	(prefix-fil (company-fuzzy--backend-prefix backend 'filter))
+	690	temp-candidates)
+	691	(when prefix-get
+	692	(setq temp-candidates (company-fuzzy--call-backend backend 'candidates prefix-get)))
+	693	;; NOTE: Do the very basic filtering for speed up.
+	694	;;
+	695	;; The function `company-fuzzy--match-string' does the very first basic
+	696	;; filtering in order to lower the performance before sending to function
+	697	;; scoring engine.
+	698	(when (and (not company-fuzzy--is-trigger-prefix-p)
+	699	(company-fuzzy--valid-candidates-p temp-candidates)
+	700	prefix-fil)
+	701	(setq temp-candidates (company-fuzzy--match-string prefix-fil temp-candidates)))
+	702	;; NOTE: Made the final completion.
+	703	(company-fuzzy--collect-candidates backend temp-candidates)))
+	704
+	705	(defun company-fuzzy--register-candidates (backend candidates)
+	706	"Register CANDIDATES with BACKEND id."
+	707	(delete-dups candidates)
+	708	(ht-set company-fuzzy--candidates backend (copy-sequence candidates)))
+	709
+	710	(defun company-fuzzy--collect-candidates (backend candidates)
+	711	"Collect BACKEND's CANDIDATES by it's type."
+	712	(cond
+	713	;; NOTE: Asynchronous
+	714	((company-fuzzy--async-candidates-p candidates)
+	715	(ignore-errors
+	716	(funcall (cdr candidates)
+	717	(lambda (async-candidates)
+	718	(company-fuzzy--register-candidates backend async-candidates)))))
+	719	;; NOTE: Synchronous
+	720	;;
+	721	;; This is the final ensure step before processing it to scoring phase.
+	722	;; We confirm candidates by adding it to `company-fuzzy--candidates'.
+	723	;; The function `company-fuzzy--valid-candidates-p' is use to ensure the
+	724	;; candidates returns a list of strings, which this is the current only valid
+	725	;; type to this package.
+	726	((company-fuzzy--valid-candidates-p candidates)
+	727	(company-fuzzy--register-candidates backend candidates))))
+	728
+	729	(defun company-fuzzy--get-prefix ()
+	730	"Set the prefix just right before completion."
+	731	(setq company-fuzzy--is-trigger-prefix-p nil
+	732	company-fuzzy--prefix (or (ignore-errors (company-fuzzy--furthest-prefix))
+	733	(ignore-errors (company-fuzzy--generic-prefix))
+	734	(ffap-guesser))
+	735	company-fuzzy--prefix-first (ignore-errors (substring company-fuzzy--prefix 0 1)))
+	736	company-fuzzy--prefix) ; make sure return it
+	737
+	738	(defun company-fuzzy-all-other-backends (command &optional arg &rest ignored)
+	739	"Backend source for all other backend except this backend, COMMAND, ARG, IGNORED."
+	740	(interactive (list 'interactive))
+	741	(cl-case command
+	742	(`interactive (company-begin-backend 'company-fuzzy-all-other-backends))
+	743	(`prefix (company-fuzzy--get-prefix))
+	744	(`annotation (company-fuzzy--extract-annotation arg))
+	745	(`candidates (company-fuzzy-all-candidates))
+	746	(`pre-render (company-fuzzy--pre-render arg (nth 0 ignored)))
+	747	(t (company-fuzzy--backend-command arg command))))
+	748
+	749	;;
+	750	;; (@* "Users" )
+	751	;;
+	752
+	753	(defun company-fuzzy--ensure-local ()
+	754	"Ensure modified variable effect locally."
+	755	(make-local-variable 'company-fuzzy--backends)
+	756	(make-local-variable 'company-fuzzy--recorded-backends)
+	757	(make-local-variable 'company-backends))
+	758
+	759	(defun company-fuzzy--backend-organize ()
+	760	"Organize backend after modified the backend list."
+	761	(if company-fuzzy-mode
+	762	(setq company-fuzzy--backends (delete-dups company-fuzzy--backends)
+	763	company-fuzzy--recorded-backends (delete-dups company-fuzzy--recorded-backends))
+	764	(setq company-backends (delete-dups company-backends))))
+	765
+	766	;;;###autoload
+	767	(defun company-fuzzy-backend-add (backend)
+	768	"Safe way to add BACKEND."
+	769	(company-fuzzy--ensure-local)
+	770	(if company-fuzzy-mode
+	771	(progn
+	772	(add-to-list 'company-fuzzy--backends backend t)
+	773	(add-to-list 'company-fuzzy--recorded-backends backend t))
+	774	(add-to-list 'company-backends backend t))
+	775	(company-fuzzy--backend-organize))
+	776
+	777	;;;###autoload
+	778	(defun company-fuzzy-backend-remove (backend)
+	779	"Safe way to remove BACKEND."
+	780	(company-fuzzy--ensure-local)
+	781	(if company-fuzzy-mode
+	782	(progn
+	783	(setq company-fuzzy--backends (cl-remove backend company-fuzzy--backends)
+	784	company-fuzzy--recorded-backends (cl-remove backend company-fuzzy--recorded-backends)))
+	785	(setq company-backends (cl-remove backend company-backends)))
+	786	(company-fuzzy--backend-organize))
+	787
+	788	(defun company-fuzzy--insert-to (list elm n)
+	789	"Insert into list LIST an element ELM at index N.
+	790
+	791	If N is 0, ELM is inserted before the first element.
+	792
+	793	The resulting list is returned. As the list contents is mutated
+	794	in-place, the old list reference does not remain valid."
+	795	(let* ((padded-list (cons nil (copy-sequence list)))
+	796	(c (nthcdr n padded-list)))
+	797	(setcdr c (cons elm (cdr c)))
+	798	(cdr padded-list)))
+	799
+	800	(defun company-fuzzy--insert-before (list elm new-elm)
+	801	"Add a NEW-ELM to the LIST before ELM."
+	802	(let ((position (or (cl-position elm list :test 'equal) 0)))
+	803	(company-fuzzy--insert-to list new-elm position)))
+	804
+	805	(defun company-fuzzy--insert-after (list elm new-elm)
+	806	"Add a NEW-ELM to the LIST after ELM."
+	807	(let ((position (or (cl-position elm list :test 'equal) 0)))
+	808	(company-fuzzy--insert-to list new-elm (1+ position))))
+	809
+	810	;;;###autoload
+	811	(defun company-fuzzy-backend-add-before (backend target)
+	812	"Add the BACKEND before the TARGET backend."
+	813	(company-fuzzy--ensure-local)
+	814	(if company-fuzzy-mode
+	815	(setq company-fuzzy--backends
+	816	(company-fuzzy--insert-before company-fuzzy--backends
+	817	target backend)
+	818	company-fuzzy--recorded-backends
+	819	(company-fuzzy--insert-before company-fuzzy--recorded-backends
+	820	target backend))
+	821	(setq company-backends
+	822	(company-fuzzy--insert-before company-backends
+	823	target backend)))
+	824	(company-fuzzy--backend-organize))
+	825
+	826	;;;###autoload
+	827	(defun company-fuzzy-backend-add-after (backend target)
+	828	"Add the BACKEND after the TARGET backend."
+	829	(company-fuzzy--ensure-local)
+	830	(if company-fuzzy-mode
+	831	(setq company-fuzzy--backends
+	832	(company-fuzzy--insert-after company-fuzzy--backends
+	833	target backend)
+	834	company-fuzzy--recorded-backends
+	835	(company-fuzzy--insert-after company-fuzzy--recorded-backends
+	836	target backend))
+	837	(setq company-backends
+	838	(company-fuzzy--insert-after company-backends
+	839	target backend)))
+	840	(company-fuzzy--backend-organize))
+	841
+	842	;;
+	843	;; (@* "Plugins" )
+	844	;;
+	845
+	846	(defun company-fuzzy--lsp-connected-p ()
+	847	"Return non-nil if lsp is connected."
+	848	(or (bound-and-true-p lsp-managed-mode)
+	849	(bound-and-true-p eglot--managed-mode)))
+	850
+	851	(defun company-fuzzy--lsp-after-enabled (&rest _)
+	852	"Hook run after LSP is enabled."
+	853	(when (company-fuzzy--lsp-connected-p)
+	854	;; No need to check for `company-fuzzy-mode' is on or not since this
+	855	;; is hook only added when `company-fuzzy-mode' is on.
+	856	(setq-local company-backends '(company-fuzzy-all-other-backends))))
+	857
+	858	(defun company-fuzzy--lsp-passthrough (backend)
+	859	"Respect `capf' BACKEND when LSP is available."
+	860	(when (memq backend '(company-capf))
+	861	(company-fuzzy--lsp-connected-p)))
+	862
+	863	(defun company-fuzzy-yasnippet--completions-for-prefix (fnc &rest args)
+	864	"Wrap around `company-yasnippet--completions-for-prefix' function in order to
+	865	get all possible candidates.
+	866
+	867	Arguments FNC and ARGS are used to apply original operations."
+	868	(when company-fuzzy-mode
+	869	;; `prefix' came from `company-fuzzy--backend-prefix-get', so we simply
+	870	;; replace set `key-prefix' to `prefix'.
+	871	(setf (nth 1 args) (nth 0 args)))
+	872	(apply fnc args))
+	873
+	874	(provide 'company-fuzzy)
+	875	;;; company-fuzzy.el ends here
+	876

init.el ¶

12 additions and 39 deletions.

View changes Hide changes

;; Copyright © 2018-2022 Maarten Vangeneugden
;; Author: Maarten Vangeneugden <contact_me@maartenv.be>
;; URL: https://maartenv.be
;;
;; Welcome to Ghent Emacs.
;;
;; This is the configuration file for Ghent Emacs, a GNU Emacs derivative
;; developed in the city of Ghent, Belgium, by a student of Engineering
;; Informatics at Ghent University.
;;
;; License: GPLv3+

;; USAGE:
;; This configuration file uses the use-package declaration, that means the
;; settings are a bit different from what you'd normally do in a GNU Emacs
;; init.el file. Consult https://github.com/jwiegley/use-package for info on how
;; to correctly write package configuration.

(eval-when-compile
;; Do you get shit like "wrong number of arguments" that completely freezes up
;; the autocompleter? Fix it by removing the company-fuzzy.elc file from the
;; .emacs elpa layers directory, and replacing company-fuzzy.el with the
;; company-fuzzy.el file in the rc repository. Just adding this fixes a bug that
;; apparently nobody else on the internet has or has managed to figure out a fix for.


(eval-when-compile
  (require 'use-package))
;(require 'diminish)                ;; if you use :diminish
(require 'bind-key)                ;; if you use any :bind variant

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(custom-safe-themes
   '("763bf89898a06b03f7b65fbc29857a1c292e4350246093702fdbd6c4e46e2cf0" "78e6be576f4a526d212d5f9a8798e5706990216e9be10174e3f3b015b8662e27" "d9646b131c4aa37f01f909fbdd5a9099389518eb68f25277ed19ba99adeb7279" "8b58ef2d23b6d164988a607ee153fd2fa35ee33efc394281b1028c2797ddeebb" "f9aede508e587fe21bcfc0a85e1ec7d27312d9587e686a6f5afdbb0d220eab50" "83ae405e25a0a81f2840bfe5daf481f74df0ddb687f317b5e005aa61261126e9" "c433c87bd4b64b8ba9890e8ed64597ea0f8eb0396f4c9a9e01bd20a04d15d358" "a24c5b3c12d147da6cef80938dca1223b7c7f70f2f382b26308eba014dc4833a" "732b807b0543855541743429c9979ebfb363e27ec91e82f463c91e68c772f6e3" "a2cde79e4cc8dc9a03e7d9a42fabf8928720d420034b66aecc5b665bbf05d4e9" "8aebf25556399b58091e533e455dd50a6a9cba958cc4ebb0aab175863c25b9a4" "bd7b7c5df1174796deefce5debc2d976b264585d51852c962362be83932873d9" default))
 '(inhibit-startup-screen t)
 '(org-agenda-files nil nil nil "Customized with use-package org")
 '(package-selected-packages
   '(company-fuzzy web-mode use-package srefactor spacemacs-theme spaceline solarized-theme rainbow-delimiters pretty-mode page-break-lines monokai-theme helm general evil dashboard dante company-ycmd company-flx company-anaconda clang-format auto-package-update auctex a))
 '(spaceline-inflation 1 t nil "Customized with use-package spaceline")
 '(spaceline-inflation 1 t nil "Customized with use-package spaceline")
 '(spaceline-toggle-buffer-size-off nil t nil "Customized with use-package spaceline")
 '(warning-suppress-types '((comp))))
;(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 ;'(default ((((class color) (min-colors 89)) (:foreground "#ffffff" :background "#263238")))))


(add-to-list 'default-frame-alist
             '(font . "Hack-11"))

;; To get rid of those FUCKING ANNOYING BACKUP FILES FUCKING HELL DUDE
(setq backup-directory-alist '(("." . "~/.emacs.d/backup"))
  backup-by-copying t    ; Don't delink hardlinks
  version-control t      ; Use version numbers on backups
  delete-old-versions t  ; Automatically delete excess backups
  kept-new-versions 20   ; how many of the newest versions to keep
  kept-old-versions 5    ; and how many of the old
  )
;; And yes I copied it from SO, suck it: https://stackoverflow.com/questions/2680389/how-to-remove-all-files-ending-with-made-by-emacs

;; Disables the use of tabs, replaces them with spaces
(setq-default indent-tabs-mode nil)

;; Activate UTF-8 throughout Ghent Emacs
(prefer-coding-system 'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING))

;; Line numbering config
(global-display-line-numbers-mode)
(setq display-line-numbers-mode t)
(setq display-line-numbers-widen t)
(setq display-line-numbers-type 'relative)
(setq display-line-numbers-current-absolute t)

(setq mouse-wheel-scroll-amount '(1 ((shift) . 1)))
(setq scroll-step 1)
(setq scroll-margin 10) ;; Keeps 10 lines above and down always visible if still left

;; Enable line breaks in all modes at column 80
(setq-default auto-fill-function 'do-auto-fill)
(setq-default fill-column 80)

(setq ring-bell-function 'ignore) ;; Disables the FUCKING ANNOYING BEEPS HOLY SHIT

;; Setup packages
;(package-initialize)
(require 'package)
(setq package-enable-at-startup nil)
(add-to-list 'package-archives '("org" . "https://orgmode.org/elpa/"))
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/"))
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
(package-install 'use-package))




;; Next two lines allow foregoing :ensure t on all packages
;; :ensure t simply makes sure that, if a package isn't installed on this
;; machine, it's automatically fetched and installed.
;; This doesn't keep packages up-to-date, cfr. auto-package-update for that
(require 'use-package-ensure)
(setq use-package-always-ensure t)

;; Package for automatic updating of all the other packages
(use-package auto-package-update
  :config
  (setq auto-package-update-delete-old-versions t)
  (setq auto-package-update-hide-results t)
  (auto-package-update-maybe))

;; Easier keybindings so we can do more lazy loading
(use-package general
  :config
  (general-create-definer my-leader-def
	;; :prefix my-leader
	:prefix "SPC")
  (general-create-definer local-leader-def
	;; :prefix local-leader
	:prefix ","))

(use-package dashboard
  :init
  (setq dashboard-banner-logo-title "") ; It's nicer to just not have a title text.
  (setq dashboard-startup-banner "~/ghent-emacs.png")
  :config
  (dashboard-setup-startup-hook))

;; AUCTeX configuration
;; Partly inspired by https://piotr.is/2010/emacs-as-the-ultimate-latex-editor/
;;;;(use-package auctex
  ;;:init
  ;;(setq TeX-auto-save t)
  ;;(setq TeX-parse-self t)
  ;;(setq Tex-save-query nil)
  ;;)

;; Updates all packages automatically
(use-package auto-package-update
  :config
  (setq auto-package-update-delete-old-versions t)
  (setq auto-package-update-hide-results t)
  (auto-package-update-maybe))

;; UI settings
(tool-bar-mode -1)
(menu-bar-mode -1)
(toggle-scroll-bar -1)

;; Tabs and width
(setq-default tab-width 4)
(setq-default c-basic-offset 4)

(use-package spaceline
    :init
    (setq frame-char-height 35)
    (setq powerline-height 35)
    :custom
     (spaceline-toggle-buffer-size-off)
     ;(setq powerline-height 21)
  (spaceline-inflation 1)
  (powerline-default-separator 'slant)
  :config
  (spaceline-spacemacs-theme)
  (setq spaceline-highlight-face-func 'spaceline-highlight-face-evil-state)) 


(use-package monokai-theme
    :config
    (load-theme 'monokai t)
    (setq monokai-variable-pitch-mode t))
;; When using solarized as theme, put in :config
;; (setq x-underline-at-descent-line t)
;; Which will block an ugly line being drawn trhough the modeline.

;(add-hook 'org-mode-hook '(lambda () (setq fill-column 80)))
;(add-hook 'org-mode-hook 'auto-fill-mode)
;; (Programming) languages



(use-package dante
  :after haskell-mode
  :commands 'dante-mode
  :init
  (add-hook 'haskell-mode-hook 'dante-mode)
  (add-hook 'haskell-mode-hook 'flycheck-mode)
  (add-hook 'haskell-mode-hook '
            (lambda () (modify-syntax-entry ?_ "w")))
  )

    
;; HTML/CSS/Django
(use-package web-mode
  :mode "\\.html?\\.djhtml\\'"
  :init
  (add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
  (setq web-mode-markup-indent-offset 4)
  (setq web-mode-css-indent-offset 4)
  (setq web-mode-code-indent-offset 4)
  ;(setq web-mode-engines-alist
;	'(("django"    . "\\.html\\"))) ;; FIXME this doesn't work yet. IDK why.
  :custom ;; Next lines disable all the automatic completion stuff that I didn't explicitely ask for
  (web-mode-enable-auto-pairing nil)
  (web-mode-enable-auto-closing nil)
  (web-mode-enable-auto-expanding nil)
  (web-mode-enable-auto-opening nil)
  (web-mode-enable-auto-quoting nil))


;;(use-package ycmd-mode
  ;;:ensure ycmd
  ;;;:hook (after-init . global-ycmd-mode)
  ;;:hook (haskell-mode elisp-mode python-mode c-mode c++-mode) ; Add the modes of the languages where YCM
                                      ;;; needs to kick in
  ;;:init
  ;;; Old paths
  ;;;(set-variable 'ycmd-server-command `("/usr/bin/python" ,(file-truename "/usr/share/vim/vimfiles/third_party/ycmd/ycmd/")))
  ;;;(set-variable 'ycmd-global-config "/home/simba/.emacs.d/lang/ycm_conf.py")
  ;;(set-variable 'ycmd-server-command `("python" ,(file-truename "~/ycmd/ycmd")))
  ;;(set-variable 'ycmd-global-config (file-truename "~/Repositories/rc/.ycm_extra_conf.py"))
  ;;(set-variable 'ycmd-global-modes 'all) ; Activates YCMD in 'all' major modes,
                                        ;;; not only those in ycmd-file-type-map
  ;;;(set-variable 'ycmd-extra-conf-whitelist '("/home/jorrit/Dev/*"))
  ;;:config
  ;;(setq url-show-status nil)  ; Makes those FUCKING annoying messages SHUT THE HELL UP
  ;;(setq request-message-level -1)
  
  ;;(use-package flycheck-ycmd
	;;:ensure t
	;;:commands (flycheck-ycmd-setup)
	;;:hook (ycmd-mode . flycheck-ycmd-setup)
	;;:init
	;;(setq flycheck-clang-language-standard "c++11")
	;;(when (not (display-graphic-p))
      ;;(setq flycheck-indication-mode nil))))

(use-package company
 :hook (after-init . global-company-mode)
 :init
 (company-tng-configure-default)  ; Use <TAB> to scroll in completion options
 (setq company-minimum-prefix-length 2)
 (setq company-idle-delay 0.0))
 ;:config
 ;;(use-package company-ycmd-mode
	;;:ensure company-ycmd
	;;:commands (company-ycmd-setup)
	;;:hook (ycmd-mode . company-ycmd-setup))
 ;;(use-package company-flx
              ;;:ensure t
              ;;:config
              ;;(company-flx-mode +1)))
;;
(use-package company-fuzzy

(use-package company-fuzzy
  :hook (company-mode . company-fuzzy-mode)
  :init
  (setq company-fuzzy-sorting-backend 'flx
        company-fuzzy-prefix-on-top nil
        company-fuzzy-prefix-on-top nil
        company-fuzzy-history-backends '(company-yasnippet)
        company-fuzzy-trigger-symbols '("." "->" "<" "\"" "'" "@")))

(global-company-fuzzy-mode 1)

(use-package clang-format
  :general
  (local-leader-def
   :states 'normal
   :modes '(c-mode-map c++-mode-map)
   "b" '(:ignore t :which-key "clang")
   "bf" 'clang-format-buffer)
  :init
  (setq-default clang-format-style "{BasedOnStyle: llvm, IndentWidth: 4}"))

;; eViL-mode
(use-package evil
  :hook (after-init . evil-mode)
  :bind (:map evil-normal-state-map ;; Scrolls over lines correctly
              ("j" . evil-next-visual-line)
              ("k" . evil-previous-visual-line))
  :general
  (my-leader-def
	:states 'normal
    "b" '(:ignore t :which-key "buffer")
    "g" '(:ignore t :which-key "magit")
    "f" '(:ignore t :which-key "files")
	"bk" 'kill-this-buffer
	"bd" 'kill-other-buffers
	"bh" 'switch-to-home-buffer
	"br" 'revert-buffer
	"h" 'split-window-vertically
	"v" 'split-window-horizontally)
  (local-leader-def
	:states 'normal
    ;; General lang options
	"c" 'compile)
  :init
  (setq evil-find-skip-newlines t) ;; Allows f/F/t/T to search beyond CR/LF
  (setq evil-undo-system 'undo-redo)  ;; Just uses standard undo-redo behaviour
  ;; a normal human expects
  (setq evil-want-C-u-scroll t)) ;; Activates c-u scroll to above.

;; About smooth-scrolling: I'd normally just use some variables for scrolling
;; but they all fail with org-mode. This package fixes everything that's wrong for me.
;(use-package smooth-scrolling
   ;:config
   ;(smooth-scrolling-mode 1))

(use-package org
  :pin "org"
  ; FIXME This causes some errors with bind-keys or what have you. Commented
  ; until it is fixed.
  ;:bind (:bind-keymap
  ;        ("C-c x" . org-todo-state-map)
  ;       :map org-todo-state-map
  ;        ("x" . #'(lambda nil (interactive) (org-todo "CANCELLED")))
  ;        ("d" . #'(lambda nil (interactive) (org-todo "DONE")))
  ;        ("f" . #'(lambda nil (interactive) (org-todo "DEFERRED")))
  ;        ("l" . #'(lambda nil (interactive) (org-todo "DELEGATED")))
  ;        ("s" . #'(lambda nil (interactive) (org-todo "STARTED")))
  ;        ("w" . #'(lambda nil (interactive) (org-todo "WAITING"))))
;         :map org-mode-map
;          ("C-c x" . org-todo-state-map))
   :init
  (define-key mode-specific-map [?a] 'org-agenda)
  :custom
  ;; Because I use XeLaTeX (it's objectively better), some variables need to be
  ;; set so org-mode knows what to call.

  ;; Okay, so you cán export asynchronous so compiling your PDF doesn't lock up
  ;; the editor completely, but for one reason or another, you MUST set the
  ;; async-debug to nil. Otherwise it will constantly "exit abnormally" without
  ;; reason. This fixes it, who knows why.
  (org-export-async-debug nil)
  
  (org-latex-compiler 'xelatex)  ; Makes sure the XeLaTeX compiler is used
  
  ; Tells Org to use dvisvgm because dvipng does not support XeLaTeX's output format
  (org-preview-latex-default-process 'dvisvgm)
  
  ; This edits the preview process so it works correctly with XeLaTeX.
  ; Changes: 
  ; - "latex" to "xelatex" 
  ; - Added the "-no-pdf" flag so it prints an XDV file instead of PDF.
  ; - change input type from dvi to xdv
  ; - Only leave the dvisvgm option because I don't need the others
  (org-preview-latex-process-alist
   (quote
    ((dvisvgm :programs
              ("xelatex" "dvisvgm")
              :description "dvi > svg" :message "you need to install the programs: xelatex and dvisvgm." :use-xcolor t :image-input-type "xdv" :image-output-type "svg" :image-size-adjust
              (1.7 . 1.5)
              :latex-compiler
              ("xelatex -interaction nonstopmode -no-pdf -output-directory %o %f")
              :image-converter
              ("dvisvgm %f -n -b min -c %S -o %O")))))

  ;; Sets the formatting options. I only changed :scale to 1.6, but I don't know
  ;; how to change only thát, so for now I'm configuring the entire variable
  (org-format-latex-options (quote
   (:foreground default :background default :scale 1.6 :html-foreground "Black" :html-background "Transparent" :html-scale 1.0 :matchers
             ("begin" "$1" "$" "$$" "\\(" "\\["))))
    
  ;; Sets the directory in which the preview fragments are stored to the /tmp
  ;; folder. Otherwise it clutters up the folder in which the source resides
  ;; with what are essentially cache files.
  (org-preview-latex-image-directory "/tmp/ltximg/")
  
  ;; Following customizations are in regard to org-agenda configuration.
  (org-agenda-files (quote ("~/shared/planning/planning.org")))
  (org-default-notes-file "~/shared/planning/notes.org")
  (org-agenda-span 62)
  (org-deadline-warning-days 14)
  (org-agenda-show-all-dates t)
  (org-agenda-skip-deadline-if-done t)
  (org-agenda-skip-scheduled-if-done t)
  (org-agenda-start-on-weekday nil)
  (org-reverse-note-order t)
  (org-fast-tag-selection-single-key (quote expert))
  (org-agenda-custom-commands
    (quote (("d" todo "DELEGATED" nil)
      ("c" todo "DONE|DEFERRED|CANCELED" nil)
      ("w" todo "WAITING" nil)
      ("W" agenda "" ((org-agenda-ndays 21)))
      ("A" agenda ""
        ((org-agenda-skip-function
          (lambda nil
      (org-agenda-skip-entry-if (quote notregexp) "\\=.*\\[#A\\]")))
        (org-agenda-ndays 1)
        (org-agenda-overriding-header "Today's Priority #A tasks: ")))
      ("u" alltodo ""
        ((org-agenda-skip-function
          (lambda nil
      (org-agenda-skip-entry-if (quote scheduled) (quote deadline)
              (quote regexp) "\n]+>")))
        (org-agenda-overriding-header "Unscheduled TODO entries: "))))))
  (org-capture-store-without-prompt t)
  (org-capture-templates
    (quote ((116 "* TODO %?\n  %u" "~/Repositories/private/org/planning.org" "Tasks")
      (110 "* %u %?" "~/Repositories/private/org/notes.org" "Notes"))))
  (capture-annotation-functions (quote (org-capture-annotation)))
  (capture-handler-functions (quote (org-capture-handler))))

  ;:general
  ;(local-leader-def
  ;  :states 'normal
  ;  :keymaps 'org-mode-map
;	"e" 'org-export-dispatch
;	"x" 'org-table-export
;	"." 'org-time-stamp
;	"t" 'org-twbs-export-to-html
;	"s" 'org-schedule
;	"d" 'org-deadline
;	"'" 'org-edit-special)
;  :config
;  ;; log todo items with timestamp
;  (setq org-log-done 'time))

(use-package helm
  :hook (after-init . helm-mode)
  :commands (helm-autoresize-mode)
  :init
  ;; (defvar helm-google-suggest-use-curl-p)
  (defvar helm-ff-search-library-in-sexp)
  (defvar helm-echo-input-in-header-line)
  (defvar helm-ff-file-name-history-use-recentf)
  :general
  (general-define-key
   "M-x" 'helm-M-x
   "M-:" 'helm-eval-expression
   "C-c h" 'helm-command-prefix)
  (general-define-key
   :keymaps 'helm-map
   "<tab>" 'helm-execute-persistent-action
   "C-i" 'helm-execute-persistent-action
   "C-z" 'helm-select-action)
  (my-leader-def
	:states 'normal
	"bb" 'helm-buffers-list
	"ff" 'helm-find-files
	"p" 'helm-show-kill-ring)
  :config
  (setq helm-split-window-inside-p           t ; open helm buffer inside current window, not occupy whole other window
	helm-move-to-line-cycle-in-source     t ; move to end or beginning of source when reaching top or bottom of source.
	helm-ff-search-library-in-sexp        t ; search for library in `require' and `declare-function' sexp.
	helm-scroll-amount                    8 ; scroll 8 lines other window using m-<next>/m-<prior>
	helm-ff-file-name-history-use-recentf t
	helm-echo-input-in-header-line t)

  ;; hide some autogenerated files from helm
  (setq helm-ff-skip-boring-files t)
  ;; (add-to-list 'helm-boring-file-regexp-list "\\~$")
  
  (setq helm-autoresize-max-height 0)
  (setq helm-autoresize-min-height 20)
  (helm-autoresize-mode 1))


(use-package rainbow-delimiters
  :hook (prog-mode . rainbow-delimiters-mode))

;; Settings for having an LaTeX beamer class export tool
(unless (boundp 'org-export-latex-classes)
(setq org-export-latex-classes nil))
(add-to-list 'org-export-latex-classes
;; beamer class, for presentations
'("beamer"
    "\\documentclass[11pt]{beamer}\n
    \\mode<{{{beamermode}}}>\n
    \\usetheme{{{{beamertheme}}}}\n
    \\usecolortheme{{{{beamercolortheme}}}}\n
    \\beamertemplateballitem\n
    \\setbeameroption{show notes}
    \\usepackage[utf8]{inputenc}\n
    \\usepackage[T1]{fontenc}\n
    \\usepackage{hyperref}\n
    \\usepackage{color}
    \\usepackage{listings}
    \\lstset{numbers=none,language=[ISO]C++,tabsize=4,
frame=single,
basicstyle=\\small,
showspaces=false,showstringspaces=false,
showtabs=false,
keywordstyle=\\color{blue}\\bfseries,
commentstyle=\\color{red},
}\n
    \\usepackage{verbatim}\n
    \\institute{{{{beamerinstitute}}}}\n          
    \\subject{{{{beamersubject}}}}\n"

    ("\\section{%s}" . "\\section*{%s}")

    ("\\begin{frame}[fragile]\\frametitle{%s}"
    "\\end{frame}"
    "\\begin{frame}[fragile]\\frametitle{%s}"
    "\\end{frame}")))

;; Adds a letter class, for formal letters

(add-to-list 'org-export-latex-classes

'("letter"
    "\\documentclass[11pt]{letter}\n
    \\usepackage[utf8]{inputenc}\n
    \\usepackage[T1]{fontenc}\n
    \\usepackage{color}"

    ("\\section{%s}" . "\\section*{%s}")
    ("\\subsection{%s}" . "\\subsection*{%s}")
    ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
    ("\\paragraph{%s}" . "\\paragraph*{%s}")
    ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))


(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(default ((t (:background nil)))))


;; This is to fix the retarded scrolling behaviour in Emacs as much as possible:
(setq redisplay-dont-pause t
  scroll-margin 1
  scroll-step 1
  scroll-conservatively 10000
  scroll-preserve-screen-position 1)
;; Stops Emacs from accelerating my scroll:
(setq mouse-wheel-progressive-speed nil)
;; Makes scrolling do 5 lines at a time, otherwise it's pretty slow
(setq mouse-wheel-scroll-amount '(2))
