You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
186 lines
8.8 KiB
186 lines
8.8 KiB
;;; alchemist-complete.el --- Complete functionality for Elixir source code -*- lexical-binding: t -*-
|
|
|
|
;; Copyright © 2014-2015 Samuel Tonini
|
|
|
|
;; Author: Samuel Tonini <tonini.samuel@gmail.com
|
|
|
|
;; This file is not part of GNU Emacs.
|
|
|
|
;; 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:
|
|
|
|
;; Complete functionality for Elixir and Erlang source code.
|
|
|
|
;;; Code:
|
|
|
|
(defgroup alchemist-complete nil
|
|
"Complete functionality for Elixir source code."
|
|
:prefix "alchemist-complete-"
|
|
:group 'alchemist)
|
|
|
|
(defvar alchemist-complete-debug-mode t)
|
|
|
|
(defun alchemist-complete-debug-mode ()
|
|
"Enables the debug mode for completion if `alchemist-complete-debug-mode'
|
|
is `nil', otherwise it disable it."
|
|
(interactive)
|
|
(setq alchemist-complete-debug-mode (not alchemist-complete-debug-mode))
|
|
(let ((state (if alchemist-complete-debug-mode
|
|
"ENABLED"
|
|
"DISABLED")))
|
|
(message "Alchemist complete debug mode is: %s" state)))
|
|
|
|
(defun alchemist-complete--concat-prefix-with-functions (prefix functions &optional add-prefix)
|
|
(let* ((prefix (mapconcat 'concat (butlast (split-string prefix "\\.") 1) "."))
|
|
(candidates (mapcar (lambda (c) (concat prefix "." c)) (cdr functions))))
|
|
(if add-prefix
|
|
(push prefix candidates)
|
|
candidates)))
|
|
|
|
(defun alchemist-complete--add-prefix-to-function (prefix function)
|
|
(let* ((prefix (mapconcat 'concat (butlast (split-string prefix "\\.") 1) "."))
|
|
(candidate (concat prefix "." function)))
|
|
candidate))
|
|
|
|
(defun alchemist-complete--build-candidates (a-list)
|
|
(let* ((search-term (car a-list))
|
|
(candidates (mapcar (lambda (f)
|
|
(let* ((candidate f)
|
|
(meta (if (string-match-p "^.+/" f)
|
|
(replace-regexp-in-string "^.+/" "/" f)
|
|
"")))
|
|
(cond
|
|
((and (string-match-p "^:" search-term)
|
|
(not (string-match-p "\\.$" search-term)))
|
|
(propertize (concat ":" candidate)))
|
|
((string-match-p "\\." search-term)
|
|
(propertize (alchemist-complete--add-prefix-to-function search-term
|
|
(replace-regexp-in-string "/[0-9]$" "" candidate)) 'meta meta))
|
|
(t (propertize (replace-regexp-in-string "/[0-9]$" "" candidate) 'meta meta)))))
|
|
(cdr a-list))))
|
|
candidates))
|
|
|
|
(defun alchemist-complete--build-help-candidates (a-list)
|
|
(let* ((search-term (car a-list))
|
|
(candidates (cond ((> (alchemist-utils--count-char-in-str "\\." search-term) 1)
|
|
(let ((search (if (string-match-p "\\.[a-z0-9_\?!]+$" search-term)
|
|
(list (replace-regexp-in-string "\\.[a-z0-9_\?!]+$" "" search-term))
|
|
(list (replace-regexp-in-string "\\.$" "" search-term))))
|
|
(candidates (mapcar (lambda (c)
|
|
(if (string-match-p "\\.[a-z0-9_\?!]+$" search-term)
|
|
(concat (replace-regexp-in-string "\\.[a-z0-9_\?!]+$" "." search-term) c)
|
|
(concat search-term c)))
|
|
(cdr a-list))))
|
|
(append search candidates)))
|
|
((string-match-p "\\.$" search-term)
|
|
(alchemist-complete--concat-prefix-with-functions search-term a-list t))
|
|
((string-match-p "\\.[a-z0-9_\?!]+$" search-term)
|
|
(alchemist-complete--concat-prefix-with-functions search-term a-list))
|
|
(t
|
|
a-list))))
|
|
(delete-dups candidates)))
|
|
|
|
(defun alchemist-complete--output-to-list (output)
|
|
(let* ((output (replace-regexp-in-string "^cmp:" "" output))
|
|
(output (split-string output))
|
|
(output (delete nil output)))
|
|
output)
|
|
)
|
|
|
|
(defun alchemist-complete--clear-buffer (buffer)
|
|
"Clears the BUFFER from not used lines."
|
|
(with-current-buffer buffer
|
|
(delete-non-matching-lines "^cmp:" (point-min) (point-max))))
|
|
|
|
(defun alchemist-complete--elixir-complete-code (exp)
|
|
(format "
|
|
defmodule Alchemist do
|
|
def expand(exp) do
|
|
{status, result, list } = IEx.Autocomplete.expand(Enum.reverse(exp))
|
|
|
|
case { status, result, list } do
|
|
{ :no, _, _ } -> ''
|
|
{ :yes, [], _ } -> List.insert_at(list, 0, exp)
|
|
{ :yes, _, _ } -> expand(exp ++ result)
|
|
end
|
|
end
|
|
end
|
|
|
|
Alchemist.expand('%s') |> Enum.map fn (f) -> IO.puts('cmp:' ++ f) end
|
|
" exp))
|
|
|
|
(defun alchemist-complete--command (exp)
|
|
(let* ((elixir-code (alchemist-complete--elixir-complete-code exp))
|
|
(compile-option (if (and (alchemist-project-p)
|
|
(alchemist-project--load-compile-when-needed-setting))
|
|
""
|
|
"--no-compile"))
|
|
(command (if (alchemist-project-p)
|
|
(format "%s %s -e \"%s\"" alchemist-help-mix-run-command compile-option elixir-code)
|
|
(format "%s -e \"%s\"" alchemist-execute-command elixir-code)))
|
|
)
|
|
(when (alchemist-project-p)
|
|
(alchemist-project--establish-root-directory))
|
|
command))
|
|
|
|
(defun alchemist-complete--sentinel (proc callback &optional format-function)
|
|
(set-process-sentinel proc (lambda (process signal)
|
|
(cond ((equal signal "finished\n")
|
|
(alchemist-complete--clear-buffer (process-buffer process))
|
|
(let* ((candidates (alchemist-complete--output-to-list
|
|
(alchemist--utils-clear-ansi-sequences
|
|
(alchemist-utils--get-buffer-content (process-buffer process)))))
|
|
(candidates (if format-function
|
|
(funcall format-function candidates)
|
|
candidates)))
|
|
(funcall callback candidates)))
|
|
(t
|
|
(when alchemist-complete-debug-mode
|
|
(alchemist-complete--debug-message (alchemist-utils--get-buffer-content (process-buffer process))))
|
|
(funcall callback '())))
|
|
(alchemist-utils--erase-buffer (process-buffer process)))))
|
|
|
|
(defun alchemist-complete--debug-message (content)
|
|
(alchemist-message (format "== ALCHEMIST COMPLETION FAILED ==\n== OUTPUT BEGIN:\n%s== OUTPUT END:"
|
|
content)))
|
|
|
|
(defun alchemist-complete--completing-prompt (initial completing-collection)
|
|
(let* ((completing-collection (alchemist-complete--build-help-candidates completing-collection)))
|
|
(cond ((equal (length completing-collection) 1)
|
|
(car completing-collection))
|
|
(completing-collection
|
|
(completing-read
|
|
"Elixir help: "
|
|
completing-collection
|
|
nil
|
|
nil
|
|
(replace-regexp-in-string "\\.$" "" initial)))
|
|
(t initial))))
|
|
|
|
(defun alchemist-complete (exp callback)
|
|
(let* ((buffer (get-buffer-create "alchemist-complete-buffer"))
|
|
(command (alchemist-complete--command exp))
|
|
(proc (start-process-shell-command "alchemist-complete-proc" buffer command)))
|
|
(alchemist-complete--sentinel proc callback)))
|
|
|
|
(defun alchemist-complete-candidates (exp callback)
|
|
(let* ((buffer (get-buffer-create "alchemist-complete-buffer"))
|
|
(command (alchemist-complete--command exp))
|
|
(proc (start-process-shell-command "alchemist-complete-proc" buffer command)))
|
|
(alchemist-complete--sentinel proc callback #'alchemist-complete--build-candidates)))
|
|
|
|
(provide 'alchemist-complete)
|
|
|
|
;;; alchemist-complete.el ends here
|