diff options
Diffstat (limited to '')
| -rw-r--r-- | emacs.d/lisp/auto-complete/auto-complete.el | 1138 |
1 files changed, 1138 insertions, 0 deletions
diff --git a/emacs.d/lisp/auto-complete/auto-complete.el b/emacs.d/lisp/auto-complete/auto-complete.el new file mode 100644 index 0000000..cdc4e86 --- /dev/null +++ b/emacs.d/lisp/auto-complete/auto-complete.el @@ -0,0 +1,1138 @@ +;;; auto-complete.el --- Inline auto completion + +;; Copyright (C) 2008, 2009 MATSUYAMA Tomohiro + +;; Author: MATSUYAMA Tomohiro <t.matsuyama.pub@gmail.com> +;; Keywords: convenience +;; Version: 0.2.0 + +;; 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 <http://www.gnu.org/licenses/>. + +;;; Commentary: +;; +;; This extension provides a way to complete with popup menu like: +;; +;; def-!- +;; +-----------------+ +;; |defun::::::::::::| +;; |defvar | +;; |defmacro | +;; | ... | +;; +-----------------+ +;; +;; You can complete by typing and selecting menu. +;; Enjoy! + +;;; Qualification: +;; +;; This extension can work property on GNU Emacs 22 or higher. + +;;; Installation: +;; +;; To use this extension, locate all .el files of this package to your load-path directory. +;; +;; $ cp auto-complete-x.x.x/*.el ~/.emacs.d/ +;; +;; And write following code into your .emacs. +;; +;; (require 'auto-complete) +;; (global-auto-complete-mode t) + +;;; Tips: +;; +;; Use C-n/C-p to select candidates +;; -------------------------------- +;; +;; Add following code to your .emacs. +;; +;; (define-key ac-complete-mode-map "\C-n" 'ac-next) +;; (define-key ac-complete-mode-map "\C-p" 'ac-previous) +;; +;; +;; Don't start completion automatically +;; ------------------------------------ +;; +;; Add following code to your .emacs. +;; +;; (setq ac-auto-start nil) +;; (global-set-key "\M-/" 'ac-start) +;; +;; or +;; +;; ;; start completion when entered 3 characters +;; (setq ac-auto-start 3) +;; +;; +;; Stop completion +;; --------------- +;; +;; Add following code to your .emacs. +;; +;; (define-key ac-complete-mode-map "\M-/" 'ac-stop) +;; +;; Now you can stop completion by pressing M-/. +;; +;; +;; Completion by TAB +;; ----------------- +;; +;; Add following code to your .emacs. +;; +;; (define-key ac-complete-mode-map "\t" 'ac-complete) +;; (define-key ac-complete-mode-map "\r" nil) +;; +;; +;; Do What I Mean mode +;; ------------------- +;; +;; If DWIM (Do What I Mean) mode is enabled, +;; the following features is available: +;; +;; a. TAB (ac-expand) behave as completion (ac-complete) +;; when only one candidate is left +;; b. TAB (ac-expand) behave as completion (ac-complete) +;; after you select candidate +;; c. Disapear automatically when you +;; complete a candidate. +;; +;; DWIM mode is enabled by default. +;; You can enable this feature by +;; setting `ac-dwim' to t. +;; +;; (setq ac-dwim t) +;; +;; +;; Change default sources +;; ---------------------- +;; +;; (setq-default ac-sources '(ac-source-abbrev ac-source-words-in-buffer)) +;; +;; +;; Change sources for particular mode +;; ---------------------------------- +;; +;; (add-hook 'emacs-lisp-mode-hook +;; (lambda () +;; (setq ac-sources '(ac-source-words-in-buffer ac-source-symbols)))) + +;;; History: +;; +;; 2008-03-18 +;; * auto-complete.el 0.2.0 released +;; +;; 2008-03-04 +;; * fixed menu position bug +;; +;; 2008-03-02 +;; * made a source be able to be just a function which returns candidates +;; * added ac-source-words-in-all-buffer +;; +;; 2008-03-01 +;; * added basic cache facility +;; +;; 2008-02-20 +;; * fixed menu position bug at long line (thanks rubikitch <rubikitch@ruby-lang.org>) +;; * made dictionary source generator (ac-define-dictionary-source) +;; * devided into some files (auto-complete-ruby.el, auto-complete-yasnippet.el, etc) +;; +;; 2008-02-19 +;; * added ac-trigger-commands switch +;; +;; 2008-02-10 +;; * added ac-stop function (suggestion from Andy Stewart) +;; * added ac-override-local-map switch (suggestion from Andy Stewart) +;; +;; 2008-02-03 +;; * omni completion redesign +;; * ac-sources is now buffer local for every buffer +;; * fixed a menu position bug (thanks Andy Stewart) +;; * fixed byte-compile warnings (thanks Andy Stewart) +;; +;; 2008-01-22 +;; * added face/selection-face property for sources +;; * supported menu scroll +;; +;; 2008-01-20 +;; * omni completion +;; +;; 2008-12-24 +;; * suppress errors on command hook +;; +;; 2008-12-03 +;; * changed ac-dwim to nil by default +;; * made menu to be able to adjust width +;; +;; 2008-12-03 +;; * renamed ac-find-function to ac-prefix-function +;; * renamed ac-target to ac-prefix +;; +;; 2008-11-26 +;; * auto-complete.el 0.1.0 released +;; +;; 2008-11-19 +;; * thanks for Taiki SUGAWARA <buzz.taiki@gmail.com> +;; * added source ac-source-abbrev +;; * added source ac-source-symbols +;; * added ac-expand-common to expand common part +;; +;; 2008-11-18 +;; * added ac-auto-start switch +;; * added ac-dwim switch +;; * changed menu popup behavior at end of window +;; * thanks rubikitch <rubikitch@ruby-lang.org>, kazu-yamamoto. +;; * fixed canceler bug +;; * changed to use overriding-local-map instead of minor mode map +;; * changed default key bindings +;; +;; 2008-11-16 +;; * supported candidates by using sources +;; * added automatically start swtich +;; * fixed some bug +;; * added source ac-source-files-in-current-dir +;; * added source ac-source-words-in-buffer +;; * added source ac-source-yasnippet +;; * renamed ac-enum-candidates-function to ac-candidate-function +;; * renamed ac-find-target-function to ac-find-function +;; * ac-find-function and ac-candidate-function is not buffer local variable now +;; * made candidates visible when you are end of line +;; +;; 2008-11-11 +;; * by reporting from rubikitch <rubikitch@ruby-lang.org> +;; * renamed hook name +;; * registered backward-delete-char as special command +;; * fixed code for creating candidates +;; * made auto-complete disabled when isearch-mode enabled +;; * added some major-mode into ac-modes +;; +;; 2008-11-09 +;; * auto-complete.el 0.0.1 released +;; * fixed double-width character displaying problem +;; * fixed menu position following tab character +;; * made candidates visible when you are end of window + +;;; TODO: +;; +;; - test facility +;; - support composed chars +;; - fuzzy match +;; - minibuffer completion +;; - dictionary +;; - documentation +;; - performance issue (cache issue) +;; - fix narrowing bug (reported by Yuto Hayamizu <y.hayamizu@gmail.com>) +;; - care about undo (buffer-disable-undo) +;; - scroll bar (visual) +;; - show description +;; - semantic +;; - use cl +;; - icon +;; - refactoring (especially menu) +;; - linum.el bug (reported by Andy Stewart) +;; - flymake bug (reported by TiagoCamargo) + +;;; Code: + + + +(defgroup auto-complete nil + "Auto completion with popup menu" + :group 'convenience + :prefix "auto-complete-") + +(defcustom ac-candidate-menu-height 10 + "Max height of candidate menu." + :type 'number + :group 'auto-complete) + +(defcustom ac-candidate-max 10 + "Max of number of candidates." + :type 'number + :group 'auto-complete) + +(defcustom ac-modes + '(emacs-lisp-mode lisp-interaction-mode + c-mode cc-mode c++-mode java-mode + perl-mode cperl-mode python-mode ruby-mode + ecmascript-mode javascript-mode js2-mode php-mode css-mode + makefile-mode sh-mode fortran-mode f90-mode ada-mode + xml-mode sgml-mode) + "Major modes `auto-complete-mode' can run on." + :type '(list symbol) + :group 'auto-complete) + +(defcustom ac-trigger-commands + '(self-insert-command) + "Trigger commands that specify whether `auto-complete' should start or not." + :type '(list symbol) + :group 'auto-complete) + +(defcustom ac-auto-start t + "Non-nil means completion will be started automatically. +Positive integer means if a length of a word you entered is larger than the value, +completion will be started automatically. +If you specify `nil', never be started automatically." + :group 'auto-complete) + +(defcustom ac-dwim nil + "Non-nil means `auto-complete' works based on Do What I Mean." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-override-local-map nil + "Non-nil mean use `ac-complete-mode-map' override local map. +Please set it to non-nil only if you faced to some problem about +minor-mode keymap conflicts." + :type 'boolean + :group 'auto-complete) + +(defface ac-candidate-face + '((t (:background "lightgray" :foreground "black"))) + "Face for candidate." + :group 'auto-complete) + +(defface ac-selection-face + '((t (:background "blue" :foreground "white"))) + "Face for the selected candidate." + :group 'auto-complete) + +(defvar auto-complete-mode-hook nil + "Hook for `auto-complete-mode'.") + +(defvar ac-menu nil + "Menu instance.") + +(defvar ac-menu-direction 1 + "Positive integer means `ac-menu' grows forward. +Or, `ac-menu' grows backward.") + +(defvar ac-menu-offset 0 + "Offset to contents.") + +(defvar ac-menu-scroll 0 + "Scroll top of `ac-menu'.") + +(defvar ac-completing nil + "Non-nil means `auto-complete-mode' is now working on completion.") + +(defvar ac-saved-window-start nil + "Saved window start value for restore.") + +(defvar ac-saved-window-hscroll nil + "Saved window hscroll value for restore.") + +(defvar ac-buffer nil + "A buffer where auto-complete is started.") + +(defvar ac-point nil + "Start point of prefix.") + +(defvar ac-old-point nil + "Previous start point of prefix.") + +(defvar ac-prefix nil + "Prefix.") +(defvaralias 'ac-target 'ac-prefix) + +(defvar ac-limit 0 + "Limit of number of candidates.") + +(defvar ac-candidates nil + "Current candidates.") + +(defvar ac-selection nil + "Current candidate index.") + +(defvar ac-dwim-enable nil + "Non-nil means DWIM completion will be allowed.") + +(defvar ac-setup-function 'ac-sources-setup + "This function will be called when `auto-complete-mode' is enabled.") + +(defvar ac-prefix-function 'ac-sources-prefix + "When `auto-complete-mode' finds it can start completion +or update candidates, it will call this function to find a +start point of the prefix. + +If this function returns a point `auto-complete-mode' +will set the substring between the point and current point to `ac-prefix'. +And also it will start completion or update candidates by using +the `ac-prefix'. + +If this function returns `nil', `auto-complete-mode' +ignore starting completion or stop completing.") +(defvaralias 'ac-find-function 'ac-prefix-function) + +(defvar ac-init-function 'ac-sources-init + "This function will be called when candidate menu is setupped.") + +(defvar ac-cleanup-function 'ac-sources-cleanup + "This function will be called when candidate menu is cleanupped") + +(defvar ac-candidate-function 'ac-sources-candidate + "This function can return candidates as list by +using the `TARGET' that is given as a first argument.") + +(defvar ac-complete-mode-map + (let ((map (make-sparse-keymap))) + (define-key map "\t" 'ac-expand) + (define-key map "\r" 'ac-complete) + + (define-key map [down] 'ac-next) + (define-key map [up] 'ac-previous) + + map) + "Keymap for completion.") + +(defvar ac-saved-local-map nil + "Old keymap before `auto-complete' activated.") + + + +;;;; Auto completion + +(defun ac-setup-menu (point width) + "Setup popup menu." + (when ac-menu + ;; reposition + (ac-menu-delete ac-menu) + (setq ac-menu nil)) + (save-excursion + (goto-char point) + (let ((column (ac-current-physical-column)) + (line (line-number-at-pos))) + (setq ac-saved-window-start (window-start)) + (setq ac-saved-window-hscroll (window-hscroll)) + (setq ac-menu-direction + (if (and (> line ac-candidate-menu-height) + (> ac-candidate-menu-height + (- + (max 1 (- (window-height) + (if mode-line-format 1 0) + (if header-line-format 1 0))) + (count-lines (window-start) (point))))) + -1 + 1)) + (let ((window-width (window-width)) + (right (- (+ column width) + (window-hscroll)))) + (if (and (> right window-width) + (>= right width) + (>= column width)) + (setq column (- column width)))) + (if (> ac-menu-direction 0) + (progn + (forward-line) + (if (eq line (line-number-at-pos)) + (newline) + (forward-line -1)) + (setq ac-menu (ac-menu-create (1+ line) column width ac-candidate-menu-height)) + (setq ac-point point)) + (setq ac-menu (ac-menu-create (- line ac-candidate-menu-height) column width ac-candidate-menu-height)) + (setq ac-point point))))) + +(defun ac-cleanup () + "Destroy popup menu." + (ac-deactivate-mode-map) + (when ac-menu + (ac-menu-delete ac-menu) + (set-window-start (selected-window) ac-saved-window-start) + (set-window-hscroll (selected-window) ac-saved-window-hscroll)) + (setq ac-menu nil) + (setq ac-menu-scroll 0) + (setq ac-completing nil) + (setq ac-point nil) + (setq ac-candidates nil) + (setq ac-selection 0) + (setq ac-selection-scroll-top 0) + (funcall ac-cleanup-function)) + +(defun ac-activate-mode-map () + "Activate `ac-complete-mode-map'." + (if ac-override-local-map + (progn + (setq ac-saved-local-map overriding-terminal-local-map) + (if (eq ac-saved-local-map ac-complete-mode-map) + ;; maybe never reach here + (setq ac-saved-local-map nil)) + (setq overriding-terminal-local-map ac-complete-mode-map)) + ;; rearrange ac-mode-map pair first + (assq-delete-all 'ac-completing minor-mode-map-alist) + (push (cons 'ac-completing ac-complete-mode-map) minor-mode-map-alist))) + +(defun ac-deactivate-mode-map () + "Deactivate `ac-complete-mode-map'." + (when (and ac-override-local-map + (eq overriding-terminal-local-map ac-complete-mode-map)) + (setq overriding-terminal-local-map ac-saved-local-map) + (setq ac-saved-local-map nil))) + +(defun ac-next () + "Select next candidate." + (interactive) + (if (interactive-p) + (setq ac-dwim-enable t)) + (if ac-candidates + (ac-select-candidate + (let ((selection (1+ ac-selection))) + (if (= selection (+ ac-menu-offset (min ac-candidate-menu-height (length ac-candidates)))) + (if (< (+ (- ac-selection ac-menu-offset) ac-menu-scroll) (1- (length ac-candidates))) + (prog1 ac-selection + (setq ac-menu-scroll (1+ ac-menu-scroll)) + (ac-redraw-candidates)) + (setq ac-menu-scroll 0) + (ac-redraw-candidates) + ac-menu-offset) + selection))))) + +(defun ac-previous () + "Select previous candidate." + (interactive) + (if (interactive-p) + (setq ac-dwim-enable t)) + (if ac-candidates + (ac-select-candidate + (let ((selection (1- ac-selection))) + (if (< selection ac-menu-offset) + (if (= ac-menu-scroll 0) + (prog1 (1- (+ ac-menu-offset (min ac-candidate-menu-height (length ac-candidates)))) + (setq ac-menu-scroll (- (length ac-candidates) (min ac-candidate-menu-height (length ac-candidates)))) + (ac-redraw-candidates)) + (setq ac-menu-scroll (1- ac-menu-scroll)) + (ac-redraw-candidates) + ac-selection) + selection))))) + +(defun ac-expand-1 () + "Try expansion." + (let ((string (overlay-get (ac-menu-line-overlay ac-menu ac-selection) 'real-string))) + (delete-region ac-point (point)) + (insert string) + (setq ac-prefix string))) + +(defun ac-expand () + "Try expansion but select next if expanded twice." + (interactive) + (if (and ac-dwim ac-dwim-enable) + (ac-complete) + (let ((target ac-prefix) + (string (ac-expand-1))) + (when (equal target string) + (ac-next) + (ac-expand-1))))) + +(defun ac-expand-common () + "Try expansion common part." + (interactive) + (let ((common (try-completion ac-prefix ac-candidates)) + (buffer-undo-list t)) + (when (stringp common) + (delete-region ac-point (point)) + (insert common) + (setq ac-prefix common)))) + +(defun ac-complete () + "Try completion." + (interactive) + (let* ((candidate (ac-get-selected-candidate)) + (action (ac-get-candidate-action candidate))) + (ac-expand-1) + (if action + (funcall action)) + (ac-abort))) + +(defun ac-abort () + "Abort completion." + (ac-cleanup)) + +(defun ac-stop () + "Stop completiong." + (interactive) + (ac-abort)) + +(defun ac-redraw-candidates () + "Redraw the menu contents." + (let ((i ac-menu-offset)) + ;; show line and set string to the line + (mapc + (lambda (candidate) + (when (< i ac-candidate-menu-height) + (ac-menu-show-line ac-menu i) + (ac-menu-set-line-string ac-menu i candidate + (if (= i ac-selection) + (or (ac-get-candidate-property 'selection-face candidate) 'ac-selection-face) + (or (ac-get-candidate-property 'candidate-face candidate) 'ac-candidate-face))) + (setq i (1+ i)))) + (nthcdr ac-menu-scroll ac-candidates)) + ;; ensure lines visible + (if (and (> ac-menu-direction 0) + (> i (- + (max 1 (- (window-height) + (if mode-line-format 1 0) + (if header-line-format 1 0))) + (count-lines (window-start) (point))))) + (recenter (- (1+ i)))) + (if (> i ac-menu-offset) + (let ((window-width (window-width)) + (right (- (+ (ac-menu-column ac-menu) (ac-menu-width ac-menu)) + (window-hscroll)))) + (if (> right window-width) + (scroll-left (- right window-width))))) + ;; hide remaining lines + (if (> ac-menu-direction 0) + (while (< i ac-candidate-menu-height) + (ac-menu-hide-line ac-menu i) + (setq i (1+ i))) + (dotimes (i ac-menu-offset) + (ac-menu-hide-line ac-menu i))))) + +(defun ac-update-candidates (candidates) + "Update candidates of popup menu." + (setq ac-menu-offset (if (> ac-menu-direction 0) + 0 + (- ac-candidate-menu-height + (min ac-candidate-menu-height + (length candidates))))) + (setq ac-selection ac-menu-offset) + (setq ac-candidates candidates) + (setq ac-dwim-enable (= (length candidates) 1)) + (if candidates + (progn + (setq ac-completing t) + (ac-activate-mode-map)) + (setq ac-completing nil) + (ac-deactivate-mode-map)) + (ac-redraw-candidates)) + +(defun ac-get-selected-candidate () + (overlay-get (ac-menu-line-overlay ac-menu ac-selection) 'real-string)) + +(defun ac-get-candidate-action (candidate) + (ac-get-candidate-property 'action candidate)) + +(defun ac-propertize-candidate (candidate &rest properties) + (apply 'propertize candidate properties)) + +(defun ac-get-candidate-property (prop candidate) + (get-text-property 0 prop candidate)) + +(defun ac-select-candidate (selection) + "Select candidate pointed by `SELECTION'." + (when ac-candidates + (let ((c1 (nth (+ (- ac-selection ac-menu-offset) ac-menu-scroll) ac-candidates)) + (c2 (nth (+ (- selection ac-menu-offset) ac-menu-scroll) ac-candidates))) + (ac-menu-set-line-string ac-menu ac-selection c1 + (or (ac-get-candidate-property 'candidate-face c1) + 'ac-candidate-face)) + (ac-menu-set-line-string ac-menu selection c2 + (or (ac-get-candidate-property 'selection-face c2) + 'ac-selection-face)) + (setq ac-selection selection)))) + +(defun ac-start () + "Start completion." + (interactive) + (let* ((point (save-excursion (funcall ac-prefix-function))) + (reposition (not (equal ac-point point)))) + (if (null point) + (ac-abort) + (setq ac-buffer (current-buffer)) + (setq ac-point point) + (when (not (equal ac-point ac-old-point)) + (setq ac-old-point point)) + (setq ac-prefix (buffer-substring-no-properties point (point))) + (setq ac-limit ac-candidate-max) + (if (or reposition (null ac-menu)) + (save-excursion + (funcall ac-init-function))) + (let* ((candidates + (if (or ac-completing + (not (integerp ac-auto-start)) + (>= (length ac-prefix) ac-auto-start)) + (save-excursion + (funcall ac-candidate-function)))) + (current-width (if ac-menu (ac-menu-width ac-menu) 0)) + (width (let ((w '(0)) s) + (dotimes (i ac-candidate-menu-height) + (setq s (nth i candidates)) + (if (stringp s) (push (string-width s) w))) + (apply 'max w)))) + (if (or reposition + (null ac-menu) + (> width current-width) + (< width (- current-width 10))) + (ac-setup-menu point (* (ceiling (/ width 10.0)) 10))) + (if (and ac-dwim + (= (length candidates) 1) + (equal (car candidates) ac-prefix) + (null (ac-get-candidate-action (car candidates)))) + (setq candidates nil)) + (ac-update-candidates candidates))))) + +(defun ac-trigger-command-p () + "Return non-nil if `this-command' is a trigger command." + (or (memq this-command ac-trigger-commands) + (and ac-completing + (memq this-command + '(delete-backward-char + backward-delete-char + backward-delete-char-untabify))))) + +(defun ac-current-physical-column () + "Current physical column. (not logical column)" + (- (point) (save-excursion (vertical-motion 0) (point)))) + +(defun ac-on-pre-command () + (progn ; ignore-errors + (if (and (not (ac-trigger-command-p)) + (or (not (symbolp this-command)) + (not (string-match "^ac-" (symbol-name this-command))))) + (ac-abort)))) + +(defun ac-on-post-command () + (progn ; ignore-errors + (if (and (or ac-auto-start + ac-completing) + (not isearch-mode) + (ac-trigger-command-p)) + (ac-start)))) + +(defun auto-complete-mode-maybe () + "What buffer `auto-complete-mode' prefers." + (if (and (not (minibufferp (current-buffer))) + (memq major-mode ac-modes)) + (auto-complete-mode 1))) + +(require 'easy-mmode) + +(define-minor-mode auto-complete-mode + "AutoComplete mode" + :lighter " AC" + :group 'auto-complete + (if auto-complete-mode + (progn + (funcall ac-setup-function) + (add-hook 'post-command-hook 'ac-on-post-command nil t) + (add-hook 'pre-command-hook 'ac-on-pre-command nil t) + (run-hooks 'auto-complete-mode-hook)) + (remove-hook 'post-command-hook 'ac-on-post-command t) + (remove-hook 'pre-command-hook 'ac-on-pre-command t) + (ac-abort))) + +(define-global-minor-mode global-auto-complete-mode + auto-complete-mode auto-complete-mode-maybe + :group 'auto-complete) + + + +;;;; Basic cache facility + +(defvar ac-clear-variables-after-save nil) + +(defun ac-clear-variable-after-save (variable) + (push variable ac-clear-variables-after-save)) + +(defun ac-clear-variables-after-save () + (dolist (variable ac-clear-variables-after-save) + (set variable nil))) + + + +;;;; Sources implementation + +(defvar ac-sources '(ac-source-words-in-buffer) + "Sources for completion. + +Source takes a form of just function which returns candidates or alist: + +init INIT-FUNC + INIT-FUNC will be called before creating candidate every time. + +candidates CANDIDATE-FUNC + CANDIDATE-FUNC will return a list of string as candidates. +CANDIDATE-FUNC should care about `ac-limit' that is specified at limit for performance. + +action ACTION-FUNC + ACTION-FUNC will be called when `ac-complete' is called. + +limit LIMIT-NUM + A limit of candidates. + +requires REQUIRES-NUM + This source will be included when `ac-prefix' length is larger than REQUIRES-NUM.") +(make-variable-buffer-local 'ac-sources) + +(defvar ac-sources-prefix-function 'ac-sources-prefix-default + "Default prefix function for sources. +You should override this variable instead of ac-prefix-function.") + +(defvar ac-current-sources nil + "Current working sources.") + +(defvar ac-omni-completion-sources nil + "An alist of REGEXP and SOURCES. +If matched regexp, switch to omni-completion mode and +use SOURCES as `ac-sources'.") +(make-variable-buffer-local 'ac-omni-completion-sources) + +(defvar ac-sources-omni-completion nil + "Non-nil means `auto-complete-mode' is now working on omni-completion.") + +(defun ac-sources-setup () + "Implementation for `ac-setup-function' by sources." + (make-local-variable 'ac-clear-variables-after-save) + (add-hook 'after-save-hook 'ac-clear-variables-after-save nil t)) + +(defun ac-sources-init () + "Implementation for `ac-init-function' by sources." + (or ac-current-sources (setq ac-current-sources ac-sources)) + (dolist (source ac-current-sources) + (let ((init-function (ac-get-source-property 'init source))) + (if init-function + (funcall init-function))))) + +(defun ac-sources-cleanup () + "Implementation for `ac-cleanup-function' by sources." + (setq ac-current-sources nil) + (setq ac-sources-omni-completion nil)) + +(defun ac-sources-prefix () + "Implemention for `ac-prefix-function' by sources." + (let (point) + (dolist (pair ac-omni-completion-sources) + (when (looking-back (car pair)) + (setq ac-current-sources (cdr pair)) + (setq ac-sources-omni-completion t) + (setq ac-completing t) + (setq point (match-end 0)))) + (or point + (if (and ac-completing ac-sources-omni-completion) + ac-point + (setq ac-current-sources ac-sources) + (setq ac-sources-omni-completion nil) + (funcall ac-sources-prefix-function))))) + +(defun ac-sources-prefix-default () + "Default implementation for `ac-sources-prefix-function'." + (require 'thingatpt) + (car-safe (bounds-of-thing-at-point 'symbol))) + +(defun ac-sources-candidate () + "Implementation for `ac-cadidates-function' by sources." + (let (candidates) + (dolist (source ac-current-sources) + (let* ((ac-limit (or (ac-get-source-property 'limit source) ac-limit)) + (requires (ac-get-source-property 'requires source)) + cand) + (when (or ac-sources-omni-completion + (>= (length ac-prefix) + (if (integerp requires) + requires + 1))) + (setq cand + (delq nil + (mapcar (lambda (candidate) + (ac-propertize-candidate candidate + 'action (ac-get-source-property 'action source) + 'face (ac-get-source-property 'candidate-face source) + 'candidate-face (ac-get-source-property 'candidate-face source) + 'selection-face (ac-get-source-property 'selection-face source))) + (funcall (ac-get-source-property 'candidates source)))))) + (if (and (> ac-limit 1) + (> (length cand) ac-limit)) + (setcdr (nthcdr (1- ac-limit) (copy-sequence cand)) nil)) + (setq candidates (append candidates cand)))) + (delete-dups candidates))) + +(defun ac-get-source-property (property source) + (if (symbolp source) + (setq source (symbol-value source))) + (if (and (functionp source) + (eq property 'candidates)) + source + (if (consp source) + (assoc-default property source)))) + + + +;;;; Standard sources + +(defun ac-candidate-words-in-buffer () + "Default implemention for `ac-candidate-function'." + (if (> (length ac-prefix) 0) + (let ((i 0) + candidate + candidates + (regexp (concat "\\b" (regexp-quote ac-prefix) "\\(\\s_\\|\\sw\\)*\\b"))) + (save-excursion + ;; search backward + (goto-char ac-point) + (while (and (< i ac-limit) + (re-search-backward regexp nil t)) + (setq candidate (match-string-no-properties 0)) + (unless (member candidate candidates) + (push candidate candidates) + (setq i (1+ i)))) + ;; search backward + (goto-char (+ ac-point (length ac-prefix))) + (while (and (< i ac-limit) + (re-search-forward regexp nil t)) + (setq candidate (match-string-no-properties 0)) + (unless (member candidate candidates) + (push candidate candidates) + (setq i (1+ i)))) + (nreverse candidates))))) + +(defvar ac-source-words-in-buffer + '((candidates . ac-candidate-words-in-buffer)) + "Source for completing words in current buffer.") + +(defvar ac-word-index nil + "Word index for individual buffer.") + +(ac-clear-variable-after-save 'ac-word-index) + +(defvar ac-source-words-in-all-buffer + '((init + . (lambda () + (dolist (buffer (buffer-list)) + (with-current-buffer buffer + (if (not (local-variable-p 'ac-word-index)) + (make-local-variable 'ac-word-index)) + (if (eq buffer ac-buffer) + (setq ac-word-index (ac-candidate-words-in-buffer)) + (if (and (null ac-word-index) + (< (buffer-size) 102400)) + (save-excursion + (goto-char (point-min)) + (while (re-search-forward "\\b\\(\\s_\\|\\sw\\)+\\b" nil t) + (let ((candidate (match-string-no-properties 0))) + (if (not (member candidate ac-word-index)) + (push candidate ac-word-index)))) + (setq ac-word-index (nreverse ac-word-index))))))))) + (candidates + . (lambda () + (let ((candidates) + (buffers (buffer-list))) + (while (and (< (length candidates) ac-limit) + buffers) + (setq candidates (append candidates (all-completions ac-prefix (buffer-local-value 'ac-word-index (car buffers))))) + (setq buffers (cdr buffers))) + candidates)))) + "Source for completing words in all buffer.") + +(defvar ac-source-symbols + '((candidates + . (lambda () + (all-completions ac-prefix obarray)))) + "Source for Emacs lisp symbols.") + +(defvar ac-source-abbrev + `((candidates + . (lambda () + (all-completions ac-prefix local-abbrev-table))) + (action + . expand-abbrev)) + "Source for abbrev.") + +(defvar ac-source-files-in-current-dir + '((candidates + . (lambda () + (all-completions ac-prefix (directory-files default-directory))))) + "Source for listing files in current directory.") + +(defun ac-filename-candidate () + (let ((dir (file-name-directory ac-prefix))) + (ignore-errors + (delq nil + (mapcar (lambda (file) + (if (not (member file '("./" "../"))) + (concat dir file))) + (file-name-all-completions + (file-name-nondirectory ac-prefix) dir)))))) + +(defvar ac-source-filename + '((candidates . ac-filename-candidate)) + "Source for completing file name.") + +(defvar ac-imenu-index nil + "Imenu index.") + +(defun ac-imenu-candidate () + (require 'imenu) + (let ((i 0) + (stack ac-imenu-index) + candidates + node) + (while (and stack + (< i ac-limit)) + (setq node (pop stack)) + (when (consp node) + (let ((car (car node)) + (cdr (cdr node))) + (if (consp cdr) + (mapc (lambda (child) + (push child stack)) + cdr) + (when (and (stringp car) + (string-match (concat "^" (regexp-quote ac-prefix)) car)) + (push car candidates) + (setq i (1+ i))))))) + (nreverse candidates))) + +(defvar ac-source-imenu + '((init + . (lambda () + (require 'imenu) + (setq ac-imenu-index + (ignore-errors (imenu--make-index-alist))))) + (candidates . ac-imenu-candidate)) + "Source for imenu.") + +(defmacro ac-define-dictionary-source (name list) + "Define dictionary source named `NAME'. +`LIST' is a list of string. +This is useful if you just want to define a dictionary/keywords source." + `(defvar ,name + '((candidates . (lambda () (all-completions ac-prefix ,list)))))) + + + +;;;; Popup menu + +(defun ac-menu-line (menu) + "Line number of `MENU'." + (nth 0 menu)) + +(defun ac-menu-column (menu) + "Column of `MENU'." + (nth 1 menu)) + +(defun ac-menu-width (menu) + "Popup menu width of `MENU'." + (nth 2 menu)) + +(defun ac-menu-height (menu) + "Popup menu height of `MENU'." + (nth 3 menu)) + +(defun ac-menu-overlays (menu) + "Overlays that `MENU' contains." + (nth 4 menu)) + +(defun ac-menu-line-overlay (menu line) + "Return a overlay of `MENU' at `LINE'." + (aref (ac-menu-overlays menu) line)) + +(defun ac-menu-hide-line (menu line) + "Hide `LINE' in `MENU'." + (let ((overlay (ac-menu-line-overlay menu line))) + (overlay-put overlay 'invisible nil) + (overlay-put overlay 'after-string nil))) + +(defun ac-menu-show-line (menu line) + "Show `LINE' in `MENU'." + (let ((overlay (ac-menu-line-overlay menu line))) + (overlay-put overlay 'invisible t))) + +(defun ac-menu-set-line-string (menu line string &optional face) + "Set contents of `LINE' in `MENU'." + (let ((overlay (ac-menu-line-overlay menu line))) + (overlay-put overlay 'real-string string) + (funcall (overlay-get overlay 'set-string-function) menu overlay string face))) + +(defun ac-menu-create-line-string (menu string) + "Adjust `STRING' into `MENU'." + (let ((length 0) + (width 0) + (menu-width (ac-menu-width menu)) + (chars (append string nil))) + (while (and + chars + (<= (setq width (+ width (char-width (car chars)))) menu-width)) + (setq length (1+ length)) + (setq chars (cdr chars))) + (if (< length (length string)) + (setq string (substring string 0 length))) + (let ((string-width (string-width string))) + (if (< string-width menu-width) + (setq string (concat string + (make-string (- menu-width string-width) ? ))))) + string)) + +(defun ac-menu-hide (menu) + "Hide `MENU'." + (dotimes (i (ac-menu-height menu)) + (ac-menu-hide-line menu i))) + +(defun ac-menu-last-line-of-buffer () + (save-excursion + (not (eq (forward-line) 0)))) + +(defun ac-menu-create (line column width height) + "Create popup menu." + (save-excursion + (let ((overlays (make-vector height nil)) + (window (selected-window))) + (goto-line line) + (dotimes (i height) + (move-to-column column) + (let (overlay begin w current-column (prefix "") (postfix "")) + (setq current-column (current-column)) + (cond + ((> current-column column) + (backward-char) + (setq current-column (current-column)) + (if (< current-column column) + (setq prefix (make-string (- column current-column) ? )))) + ((< current-column column) + (setq prefix (make-string (- column current-column) ? )))) + + (setq begin (point)) + (setq w (+ width (length prefix))) + (while (and (not (eolp)) + (> w 0)) + (setq w (- w (char-width (char-after)))) + (forward-char)) + (if (< w 0) + (setq postfix (make-string (- w) ? ))) + (if (ac-menu-last-line-of-buffer) + (setq postfix (concat postfix "\n"))) + + (setq overlay (make-overlay begin (point))) + (overlay-put overlay 'window window) + (overlay-put overlay 'prefix prefix) + (overlay-put overlay 'postfix postfix) + (overlay-put overlay 'width width) + (overlay-put overlay 'set-string-function + (lambda (menu overlay string &optional face) + (overlay-put overlay + 'after-string + (concat (overlay-get overlay 'prefix) + (propertize (ac-menu-create-line-string menu string) 'face face) + (overlay-get overlay 'postfix))))) + (aset overlays i overlay)) + (forward-line)) + (let ((i 100)) + (mapc (lambda (overlay) + (overlay-put overlay 'priority i) + (setq i (1+ i))) + (nreverse (append overlays nil)))) + (list line column width height overlays)))) + +(defun ac-menu-delete (menu) + "Delete `MENU'." + (mapcar 'delete-overlay (ac-menu-overlays menu))) + +(provide 'auto-complete) +;;; auto-complete.el ends here |