alchemist-20180312.1304.tar

alchemist-20180312.1304/0000775000175000017500000000000014133447044013007 5ustar  kimrkimralchemist-20180312.1304/alchemist-info.el0000664000175000017500000000642414133447044016241 0ustar  kimrkimr;;; alchemist-info.el --- Getting informations from the server.  -*- lexical-binding: t -*-

;; Copyright © 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:

;; Getting informations from the server.

;;; Code:

(require 'ansi-color)

(defgroup alchemist-info nil
  "Getting informations from the server."
  :prefix "alchemist-info-"
  :group 'alchemist)

(defconst alchemist-info-buffer-name "*alchemist-info-mode*"
  "Name of the Elixir info buffer.")

(defvar alchemist-info-filter-output nil)

(defvar alchemist-info-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "q") #'quit-window)
    map)
  "Keymap for `alchemist-info-mode'.")

(defun alchemist-info-datatype-filter (_process output)
  (setq alchemist-info-filter-output (cons output alchemist-info-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-create-popup alchemist-info-buffer-name
                                     (alchemist-server-prepare-filter-output alchemist-info-filter-output)
                                     #'(lambda ()
                                         (alchemist-info-mode)
                                         (ansi-color-apply-on-region (point-min) (point-max))))
    (setq alchemist-info-filter-output nil)))

(defun alchemist-info-expression-at-point ()
  "Return the expression under the cursor."
  (let (p1 p2)
    (save-excursion
      (skip-chars-backward "-_A-Za-z0-9.?!:@\'\"")
      (setq p1 (point))
      (skip-chars-forward "-_A-Za-z0-9.?!:@\'\"")
      (setq p2 (point))
      (buffer-substring-no-properties p1 p2))))

(defun alchemist-info-datatype-at-point ()
  "Return information about any datatype under the cursor."
  (interactive)
  (let ((expr (if mark-active
                  (buffer-substring-no-properties (region-beginning) (region-end))
                (alchemist-info-expression-at-point))))
    (alchemist-server-info (format "{ :type, :info, '%s' }" expr) #'alchemist-info-datatype-filter)))

(defun alchemist-info-types-at-point ()
  "Return information of types under the cursor."
  (interactive)
  (let ((expr (alchemist-info-expression-at-point)))
    (alchemist-server-info (format "{ :type, :types, '%s' }" expr) #'alchemist-info-datatype-filter)))

(defun alchemist-info-close-popup ()
  "Quit the information buffer window."
  (interactive)
  (quit-windows-on alchemist-info-buffer-name))

(define-minor-mode alchemist-info-mode
  "Minor mode for Alchemist server information.

\\{alchemist-info-mode-map}"
  nil
  " Alchemist-Info"
  alchemist-info-mode-map)

(provide 'alchemist-info)

;;; alchemist-info.el ends here
alchemist-20180312.1304/alchemist-complete.el0000664000175000017500000001522514133447044017115 0ustar  kimrkimr;;; alchemist-complete.el --- Complete functionality for Elixir source code -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

(require 'cl-lib)
(require 'dash)
(require 's)
(require 'ansi-color)
(require 'company-dabbrev-code)
(require 'alchemist-utils)

(defgroup alchemist-complete nil
  "Complete functionality for Elixir source code."
  :prefix "alchemist-complete-"
  :group 'alchemist)

(defvar alchemist-company-last-completion nil)

(defun alchemist-complete--concat-prefix-with-functions (prefix functions &optional add-prefix)
  (let* ((prefix (mapconcat 'concat (butlast (split-string prefix "\\.") 1) "."))
         (candidates (-map (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* ((case-fold-search nil)
	 (search-term (car a-list))
	 (candidates (if (string-match-p "^.+/" (car a-list))
			 a-list
		       (cdr a-list)))
	 (candidates (-map (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)))
                                   (unless (string= search-term candidate)
                                     (propertize (concat ":" candidate))
                                     ))
                                  ((string-match-p "\\." search-term)
                                   (unless (string= search-term candidate)
                                     (propertize (alchemist-complete--add-prefix-to-function (concat (alchemist-scope-extract-module search-term) ".")
                                                                                             (replace-regexp-in-string "/[0-9]$" "" candidate)) 'meta meta)))
                                  ((string-match-p "/[0-9]$" candidate)
				   (propertize (replace-regexp-in-string "/[0-9]$" "" candidate) 'meta meta))
				  ((string-match-p "^[A-Z0-9]" candidate)
				   (propertize candidate 'meta meta)))))
                             candidates))
         (candidates (-remove 'null candidates)))
    (cond
     ((and (string-match-p "\\.$" search-term)
           (not (string-match-p "\\.$" alchemist-company-last-completion)))
      (push (alchemist-utils-remove-dot-at-the-end search-term) candidates))
     (t candidates))))

(defun alchemist-complete--build-help-candidates (a-list)
  (let* ((search-term (car a-list))
         (candidates (cond ((> (alchemist-utils-count-char-occurence "\\." 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 (alchemist-utils-remove-dot-at-the-end search-term))))
                                  (candidates (-map (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))))
    (-distinct candidates)))

(defun alchemist-complete--output-to-list (output)
  (let* ((output (split-string output)))
    (-remove 'null output)))

(defun alchemist-complete--build-candidates-from-process-output (output)
  (let* ((output (alchemist-server-prepare-filter-output output))
         (candidates (if (not (s-blank? output))
                         (alchemist-complete--output-to-list
                          (ansi-color-filter-apply output))
                       '()))
         (candidates (if candidates
                         (alchemist-complete--build-candidates candidates)
                       '())))
    candidates))

(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--dabbrev-code-candidates ()
  "This function uses a piece of functionality of company-dabbrev-code backend.

Please have a look at the company-dabbrev-code function for more
detailed information."
  (let ((case-fold-search nil))
    (-distinct (company-dabbrev--search
                (company-dabbrev-code--make-regexp alchemist-company-last-completion)
                company-dabbrev-code-time-limit
                (list major-mode)
                t))))

(provide 'alchemist-complete)

;;; alchemist-complete.el ends here
alchemist-20180312.1304/alchemist-scope.el0000664000175000017500000001755114133447044016422 0ustar  kimrkimr;;; alchemist-scope.el --- Provides information about Elixir source code context   -*- lexical-binding: t -*-

;; Copyright © 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:

;; Provides information about the Elixir source code context.

;;; Code:

(require 'dash)
(require 's)

(defgroup alchemist-scope nil
  "Provides information about the Elixir source code context."
  :prefix "alchemist-scope-"
  :group 'alchemist)

(defconst alchemist-scope-defmodule-regex "defmodule \\([A-Z][A-Za-z0-9\._]+\\)\s+"
  "The regex for matching Elixir defmodule macro.")

(defconst alchemist-scope-alias-regex
  "^\s+alias\s+\\([-:_A-Za-z0-9,\.\?!\]+\\)\\(\s*,\s*as:\s*\\)?\\([-_A-Za-z0-9,\.\?!\]+\\)?\n"
  "The regex for matching Elixir alias definitions.
   Example:
   alias Phoenix.Router.Resource, as: Special")

(defconst alchemist-scope-alias-regex-two
  "^\s+alias\s+\\([-:_A-Za-z0-9,\.\?!\]+\\)\.{\\([-:_A-Za-z0-9\s,\.\?!\]+\\)}\n"
  "The regex for matching Elixir alias definitions.
   Example:
   alias List.Chars.{Atom, Float}")

(defconst alchemist-scope-use-regex
  "^\s+use\s+\\([A-Za-z0-9\.]+\\)"
  "The regex for matching Elixir use definitions.")

(defconst alchemist-scope-import-regex
  "^\s+import\s+\\([A-Za-z0-9\.]+\\)"
  "The regex for matching Elixir import definitions.")

(defun alchemist-scope-inside-string-p ()
  "Return non-nil if `point' is inside a string or heredoc."
  (let* ((pos (point))
         (parse-info (syntax-ppss pos)))
    (or (and (nth 3 parse-info)
             (nth 8 parse-info))
        (and (looking-at "\"\"\"\\|'''\\|\"\\|\'")
             (match-beginning 0)))))

(defun alchemist-scope-inside-module-p ()
  "Return non-nil if `point' is currently inside a module."
  (save-excursion
    (end-of-line)
    (let ((found-flag-p nil)
          (found-p nil))
      (while (and (not found-flag-p)
                  (re-search-backward alchemist-scope-defmodule-regex nil t))
        (when (not (alchemist-scope-inside-string-p))
          (setq found-flag-p t)
          (setq found-p t)))
      found-p)))

(defun alchemist-scope-module ()
  "Return name from the current defmodule."
  (save-excursion
    (let ((found-flag-p nil)
          (module-name ""))
      (save-match-data
        (while (and (not found-flag-p)
                    (re-search-backward alchemist-scope-defmodule-regex nil t))
          (when (not (alchemist-scope-inside-string-p))
            (setq module-name (match-string 1))
            (setq found-flag-p t))
          (when (equal 1 (line-number-at-pos (point)))
            (setq found-flag-p t)))
        module-name))))

(defun alchemist-scope-aliases ()
  "Return aliases from the current module."
  (let* ((aliases '())
         (context (alchemist-scope-module)))
    (save-excursion
      (when (alchemist-scope-inside-module-p)
        (end-of-line)
        ;; alias definition like:
        ;;
        ;;   alias Phoenix.Router.Resource, as: Special
        (while (re-search-backward alchemist-scope-alias-regex nil t)
          (when (and
                 (not (alchemist-scope-inside-string-p))
                 (equal context (alchemist-scope-module)))
            (let* ((alias (match-string 1))
                   (as (if (match-string 3) (match-string 3) nil))
                   (as (if as as (car (last (split-string alias "\\."))))))
              (setq aliases (append aliases (list (list (alchemist-utils-remove-dot-at-the-end alias)
                                                        (alchemist-utils-remove-dot-at-the-end as))))))))))
    (save-excursion
      (when (alchemist-scope-inside-module-p)
        (end-of-line)
        ;; alias definition like:
        ;;
        ;;   alias List.Chars.{Atom, Float}
        (while (re-search-backward alchemist-scope-alias-regex-two nil t)
          (when (and
                 (not (alchemist-scope-inside-string-p))
                 (equal context (alchemist-scope-module)))
            (let* ((prefix (match-string 1))
                   (alias-collection (if (match-string 2) (split-string (match-string 2) ",") nil)))
              (-map (lambda (alias)
                      (let* ((alias (replace-regexp-in-string "\s+" "" alias))
                             (namespace (format "%s.%s" prefix alias)))
                        (setq aliases (append aliases (list (list (alchemist-utils-remove-dot-at-the-end namespace)
                                                                  (alchemist-utils-remove-dot-at-the-end alias)))))))
                    alias-collection))))))
    aliases))

(defun alchemist-scope--modules (regex)
  (let ((modules '())
        (context (alchemist-scope-module)))
    (save-excursion
      (when (not (s-blank? context))
        (while (re-search-backward regex nil t)
          (when (and (match-string 1)
                     (not (alchemist-scope-inside-string-p))
                     (equal context (alchemist-scope-module)))
            (cl-pushnew (substring-no-properties (match-string 1)) modules))))
      modules)))

(defun alchemist-scope-use-modules ()
  "Return `use' introduced module names from the current module."
  (alchemist-scope--modules alchemist-scope-use-regex))

(defun alchemist-scope-import-modules ()
  "Return `import' introduced module names from the current module."
  (alchemist-scope--modules alchemist-scope-import-regex))

(defun alchemist-scope-all-modules ()
  "Return `use' and `import' introduced modules from the current module."
  (let ((current (alchemist-scope-module))
        (use (alchemist-scope-use-modules))
        (import (alchemist-scope-import-modules))
        (modules '()))
    (push current modules)
    (push use modules)
    (push import modules)
    (-flatten modules)))

(defun alchemist-scope-extract-module (expr)
  "Extract module from EXPR."
  (let* ((parts (split-string expr "\\."))
         (function (car (last parts)))
         (case-fold-search nil))
    (when (string-match-p "^[a-z_\?!]+" function)
      (delete function parts))
    (unless (string-match-p "^[a-z_\?!]+" (car parts))
      (alchemist-utils-remove-dot-at-the-end (mapconcat 'concat parts ".")))))

(defun alchemist-scope-extract-function (expr)
  "Extract function from EXPR."
  (let* ((parts (split-string expr "\\."))
         (function (car (last parts)))
         (case-fold-search nil))
    (when (and function
               (string-match-p "^[a-z_\?!]+" function))
      function)))

(defun alchemist-scope-alias-full-path (module)
  "Solve the full path for the MODULE alias."
  (if (not (s-blank? module))
      (let* ((aliases (-map (lambda (m)
                              (when (string-match-p (format "^%s" (car (cdr m))) module)
                                (replace-regexp-in-string (format "^%s" (car (cdr m))) (car m) module t)))
                            (alchemist-scope-aliases)))
             (aliases (delete nil aliases)))
        (if aliases
            (car aliases)
          module))))

(defun alchemist-scope-expression ()
  "Return the expression under the cursor."
  (let (p1 p2)
    (save-excursion
      (skip-chars-backward "-_A-Za-z0-9.?!@:")
      (setq p1 (point))
      (skip-chars-forward "-_A-Za-z0-9.?!@:")
      (setq p2 (point))
      (buffer-substring-no-properties p1 p2))))

(provide 'alchemist-scope)

;;; alchemist-scope.el ends here
alchemist-20180312.1304/alchemist-goto.el0000664000175000017500000003221014133447044016246 0ustar  kimrkimr;;; alchemist-goto.el --- Functionality to jump modules and function definitions -*- lexical-binding: t -*-

;; Copyright © 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:

;; Functionality to jump modules and function definitions

;;; Code:

(require 'cl-lib)
(require 'etags)
(require 'dash)
(require 's)
(require 'alchemist-utils)
(require 'alchemist-server)
(require 'alchemist-scope)

(defgroup alchemist-goto nil
  "Functionality to jump modules and function definitions."
  :prefix "alchemist-goto-"
  :group 'alchemist)

;; Variables

(defcustom alchemist-goto-erlang-source-dir ""
  "Path to the erlang source code."
  :type 'string
  :group 'alchemist-goto)

(defcustom alchemist-goto-elixir-source-dir ""
  "Path to the elixir source code."
  :type 'string
  :group 'alchemist-goto)

(defvar alchemist-goto--symbol-list '())
(defvar alchemist-goto--symbol-name-and-pos '())
(defvar alchemist-goto--symbol-list-bare '())
(defvar alchemist-goto--symbol-name-and-pos-bare '())
(defvar alchemist-goto-filter-output nil)
(defvar alchemist-goto-callback nil)

(defconst alchemist-goto--symbol-def-extract-regex
  "^\\s-*\\(defp?\\|defmacrop?\\|defmodule\\|defimpl\\)[ \n\t]+\\([a-z_\?!]+\\)\\(.*\\)\\(do\\|\n\\)?$")

(defconst alchemist-goto--symbol-def-regex
  "^[[:space:]]*\\(defmodule\\|defmacrop?\\|defimpl\\|defp?\\)")

;; Faces

(defface alchemist-goto--def-face
  '((t (:inherit font-lock-constant-face)))
  "Face for def* symbols."
  :group 'alchemist-goto)

(defface alchemist-goto--name-face
  '((t (:bold t)))
  "Face for def* symbol names."
  :group 'alchemist-goto)

;; Private functions

(defun alchemist-goto--build-elixir-ex-core-file (file)
  (when (string-match "\\/\\(lib\\/.+\\)\\/.+\.ex$" file)
    (let* ((file (substring-no-properties file (match-beginning 1)))
           (source-directory (alchemist-utils-add-trailing-slash
                              (expand-file-name alchemist-goto-elixir-source-dir))))
      (concat source-directory file))))

(defun alchemist-goto--build-elixir-erl-core-file (file)
  (when (string-match "\\/\\(lib\\/.+\\/src\\)\\/.+\.erl$" file)
    (let* ((file (substring-no-properties file (match-beginning 1)))
           (source-directory (alchemist-utils-add-trailing-slash
                              (expand-file-name alchemist-goto-elixir-source-dir))))
      (concat source-directory file))))

(defun alchemist-goto--build-erlang-core-file (file)
  (when (string-match "\\/\\(lib\\/.+\\/src\\)\\/.+\.erl$" file)
    (let* ((file (substring-no-properties file (match-beginning 1)))
           (source-directory (alchemist-utils-add-trailing-slash
                              (expand-file-name alchemist-goto-erlang-source-dir))))
      (concat source-directory file))))

(defun alchemist-goto-elixir-file-p (file)
  "Return non-nil if FILE is an Elixir file type."
  (string-match-p "\\.ex\\(s\\)?$" file))

(defun alchemist-goto-erlang-file-p (file)
  "Return non-nil if FILE is an Erlang file type."
  (string-match-p "\\.erl$" file))

(defun alchemist-goto--symbol-definition-p (symbol)
  (alchemist-goto--fetch-symbol-definitions)
  (if (member symbol alchemist-goto--symbol-list-bare)
      t
    nil))

(defun alchemist-goto--fetch-symbols-from-propertize-list (symbol)
  (-remove 'null (-map (lambda (e)
                         (when (string-match-p (format "^\\s-*\\(defp?\\|defmacrop?\\|defimpl\\|defmodule\\)\s+%s\\((.*\\)?$" symbol) e)
                           e)) alchemist-goto--symbol-list)))

(defun alchemist-goto--goto-symbol (symbol)
  (let ((amount (length (-remove 'null (-map (lambda (e) (when (string= symbol e) e))
                                             alchemist-goto--symbol-list-bare)))))
    (if (> amount 1)
        (let* ((selected-def (completing-read "Symbol definitions:"
                                              (alchemist-goto--fetch-symbols-from-propertize-list symbol)))
               (position (cdr (assoc selected-def alchemist-goto--symbol-name-and-pos))))
          (goto-char (if (overlayp position) (overlay-start position) position)))
      (let* ((position (cdr (assoc symbol alchemist-goto--symbol-name-and-pos-bare)))
             (position (if (overlayp position) (overlay-start position) position)))
        (when (not (equal (line-number-at-pos)
			  (line-number-at-pos position)))
          (goto-char position))))))

(defun alchemist-goto-list-symbol-definitions ()
  "List all symbol definitions in the current file like functions/macros/modules.

It will jump to the position of the symbol definition after selection."
  (interactive)
  (alchemist-goto--fetch-symbol-definitions)
  (ring-insert find-tag-marker-ring (point-marker))
  (let* ((selected-def (completing-read "Symbol definitions:" alchemist-goto--symbol-list))
         (position (cdr (assoc selected-def alchemist-goto--symbol-name-and-pos))))
    (goto-char (if (overlayp position) (overlay-start position) position))))

(defun alchemist-goto--fetch-symbol-definitions ()
  (alchemist-goto--search-for-symbols "^\\s-*\\(defp?\\|defmacrop?\\|defimpl\\|defstruct\\|defmodule\\)\s.*"))

(defun alchemist-goto--extract-symbol (str)
  (save-match-data
    (when (string-match alchemist-goto--symbol-def-extract-regex str)
      (let ((type (substring str (match-beginning 1) (match-end 1)))
            (name (substring str (match-beginning 2) (match-end 2)))
            (arguments (substring str (match-beginning 3) (match-end 3))))
        (concat
         (propertize type
                     'face 'alchemist-goto--def-face)
         " "
         (propertize name
                     'face 'alchemist-goto--name-face)
         (replace-regexp-in-string ",?\s+do:.*$" "" (replace-regexp-in-string "\s+do$" "" arguments)))))))

(defun alchemist-goto--file-contains-defs-p ()
  (alchemist-utils-occur-in-buffer-p (current-buffer) alchemist-goto--symbol-def-extract-regex))

(defun alchemist-goto-jump-to-next-def-symbol ()
  (interactive)
  (alchemist-utils-jump-to-next-matching-line alchemist-goto--symbol-def-regex 'back-to-indentation))

(defun alchemist-goto-jump-to-previous-def-symbol ()
  (interactive)
  (alchemist-utils-jump-to-previous-matching-line alchemist-goto--symbol-def-regex 'back-to-indentation))

(defun alchemist-goto--extract-symbol-bare (str)
  (save-match-data
    (when (string-match alchemist-goto--symbol-def-extract-regex str)
      (let ((name (substring str (match-beginning 2) (match-end 2))))
        name))))

(defun alchemist-goto--get-symbol-from-position (position)
  (goto-char position)
  (end-of-line)
  (let* ((end-position (point))
         (line (buffer-substring-no-properties position end-position)))
    (alchemist-goto--extract-symbol line)))

(defun alchemist-goto--get-symbol-from-position-bare (position)
  (with-current-buffer (buffer-name)
    (save-excursion
      (goto-char position)
      (end-of-line)
      (let* ((end-position (point))
             (line (buffer-substring-no-properties position end-position)))
        (alchemist-goto--extract-symbol-bare line)))))

(defun alchemist-goto--search-for-symbols (regex)
  (setq alchemist-goto--symbol-list '())
  (setq alchemist-goto--symbol-name-and-pos '())
  (setq alchemist-goto--symbol-list-bare '())
  (setq alchemist-goto--symbol-name-and-pos-bare '())
  (with-current-buffer (buffer-name)
    (save-excursion
      (goto-char (point-min))
      (save-match-data
        (while (re-search-forward regex nil t)
          (when (not (alchemist-scope-inside-string-p))
            (when (alchemist-goto--get-symbol-from-position (car (match-data)))
              (let* ((position (car (match-data)))
                     (symbol (alchemist-goto--get-symbol-from-position position))
                     (symbol-bare (alchemist-goto--get-symbol-from-position-bare position)))
                (setq alchemist-goto--symbol-list (append alchemist-goto--symbol-list (list symbol)))
                (setq alchemist-goto--symbol-name-and-pos (append alchemist-goto--symbol-name-and-pos (list (cons symbol position))))
                (setq alchemist-goto--symbol-list-bare (append alchemist-goto--symbol-list-bare (list symbol-bare)))
                (setq alchemist-goto--symbol-name-and-pos-bare (append alchemist-goto--symbol-name-and-pos-bare (list (cons symbol-bare position))))))))))))

(defun alchemist-goto--open-definition (expr)
  (let* ((module (alchemist-scope-extract-module expr))
         (aliases (alchemist-utils-prepare-aliases-for-elixir
                   (alchemist-scope-aliases)))
         (function (alchemist-scope-extract-function expr))
         (modules (alchemist-utils-prepare-modules-for-elixir
                   (alchemist-scope-all-modules))))
    (ring-insert find-tag-marker-ring (point-marker))
    (cond
     ((and (null module)
           (alchemist-goto--symbol-definition-p function)
           (not (string= (buffer-name) alchemist-help-buffer-name)))
      (alchemist-goto--goto-symbol function))
     (t
      (setq alchemist-goto-callback (lambda (file)
				      (cond ((s-blank? file)
                                             (message "Don't know how to find: %s" expr))
                                            ((file-exists-p file)
					     (alchemist-goto--open-file file module function))
                                            ((alchemist-goto-elixir-file-p file)
					     (let* ((elixir-source-file (alchemist-goto--build-elixir-ex-core-file file)))
					       (if (and elixir-source-file (file-exists-p elixir-source-file))
                                                   (alchemist-goto--open-file elixir-source-file module function)
                                                 (message "Don't know how to find: %s" expr))))
                                            ((alchemist-goto-erlang-file-p file)
                                             (let* ((elixir-source-file (alchemist-goto--build-elixir-erl-core-file file))
                                                    (erlang-source-file (alchemist-goto--build-erlang-core-file file)))
                                               (cond ((file-exists-p elixir-source-file)
                                                      (alchemist-goto--open-file elixir-source-file module function))
                                                     ((file-exists-p erlang-source-file)
                                                      (alchemist-goto--open-file erlang-source-file module function))
                                                     (t
                                                      (message "Don't know how to find: %s" expr)))))
                                            (t
                                             (pop-tag-mark)
                                             (message "Don't know how to find: %s" expr)))))
      (alchemist-server-goto (format "{ \"%s,%s\", [ context: Elixir, imports: %s, aliases: %s ] }" module function modules aliases)
                             #'alchemist-goto-filter)))))

(defun alchemist-goto--open-file (file module function)
  (let ((buf (find-file-noselect file)))
    (switch-to-buffer buf)
    (goto-char (point-min))
    (cond ((alchemist-goto-elixir-file-p file)
           (alchemist-goto--jump-to-elixir-source module function))
          ((alchemist-goto-erlang-file-p file)
           (alchemist-goto--jump-to-erlang-source module function)))))

(defun alchemist-goto--jump-to-elixir-source (module function)
  (cond
   (function
    (alchemist-goto--fetch-symbol-definitions)
    (alchemist-goto--goto-symbol function))
   (t
    (when (re-search-forward (format "\\(defmodule\\|defimpl\\|defprotocol\\)\s+%s\s+do" module) nil t)
      (goto-char (match-beginning 0))))))

(defun alchemist-goto--jump-to-erlang-source (module function)
  (when (re-search-forward (format "\\(^%s\(\\)" function) nil t)
    (goto-char (match-beginning 0)))
  (when (re-search-forward (format "\\(^-module\(%s\)\\)" (substring module 1)) nil t)
    (goto-char (match-beginning 0))))

(defun alchemist-goto-filter (_process output)
  (with-local-quit
    (setq alchemist-goto-filter-output (cons output alchemist-goto-filter-output))
    (when (alchemist-server-contains-end-marker-p output)
      (let* ((output (alchemist-server-prepare-filter-output alchemist-goto-filter-output))
	     (file output))
	(setq alchemist-goto-filter-output nil)
	(funcall alchemist-goto-callback file)))))

;; Public functions

(defun alchemist-goto-definition-at-point ()
  "Jump to the elixir expression definition at point."
  (interactive)
  (alchemist-goto--open-definition (alchemist-scope-expression)))

(defalias 'alchemist-goto-jump-back 'pop-tag-mark)

(provide 'alchemist-goto)

;;; alchemist-goto.el ends here
alchemist-20180312.1304/alchemist-iex.el0000664000175000017500000001737414133447044016101 0ustar  kimrkimr;;; alchemist-help.el --- Interaction with an Elixir IEx process

;; Copyright © 2014-2017 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:

;; Interaction with an Elixir IEx process

;;; Code:

(require 'comint)
(require 'company)
(require 'alchemist-key)
(require 'alchemist-scope)
(require 'alchemist-project)

(defgroup alchemist-iex nil
  "Interaction with an Elixir IEx process."
  :prefix "alchemist-iex-"
  :group 'alchemist)

(defcustom alchemist-iex-program-name "iex"
  "The shell command for iex."
  :type 'string
  :group 'alchemist-iex)

(defvar alchemist-iex-prompt-regexp "^\\(iex\\|\\.\\.\\.\\)(.+)>"
  "Prompt regex pattern of IEx interpreter.

Should match prompts that looks like these:
iex(1)>
...(1)>")

(defcustom alchemist-iex-prompt-read-only t
  "If non-nil, the prompt will be read-only."
  :type 'boolean
  :group 'alchemist-iex)

(defvar alchemist-iex-buffer nil
  "The buffer in which the Elixir IEx process is running.")

(defvar alchemist-iex-mode-hook nil
  "Hook for customizing `alchemist-iex-mode'.")

(defvar alchemist-iex-mode-map
  (let ((map (nconc (make-sparse-keymap) comint-mode-map)))
    (define-key map "\t" 'company-complete)
    (define-key map (kbd "TAB") 'company-complete)
    (define-key map (kbd (format "%s i r" alchemist-key-command-prefix)) 'alchemist-iex-open-input-ring)
    (define-key map (kbd (format "%s i c" alchemist-key-command-prefix)) 'alchemist-iex-clear-buffer)
    (define-key map (kbd (format "%s h e" alchemist-key-command-prefix)) 'alchemist-help-search-at-point)
    (define-key map (kbd "M-.") 'alchemist-goto-definition-at-point)
    map))

(define-derived-mode alchemist-iex-mode comint-mode "Alchemist-IEx"
  "Major mode for interacting with an Elixir IEx process.

\\<alchemist-iex-mode-map>"
  nil "Alchemist-IEx"
  (set (make-local-variable 'comint-prompt-regexp) alchemist-iex-prompt-regexp)
  (set (make-local-variable 'comint-prompt-read-only) alchemist-iex-prompt-read-only)
  (set (make-local-variable 'comint-input-autoexpand) nil)
  (set (make-local-variable 'comint-input-sender) 'alchemist-iex--send-command)
  (add-hook 'comint-output-filter-functions 'alchemist-iex-spot-prompt nil t))

(defun alchemist-iex-command (arg)
  (split-string-and-unquote
   (if (null arg) alchemist-iex-program-name
     (read-string "Command to run Elixir IEx: " (concat alchemist-iex-program-name arg)))))

(defun alchemist-iex-start-process (command)
  "Start an IEX process.
With universal prefix \\[universal-argument], prompts for a COMMAND,
otherwise uses `alchemist-iex-program-name'.
It runs the hook `alchemist-iex-mode-hook' after starting the process and
setting up the IEx buffer."
  (interactive (list (alchemist-iex-command current-prefix-arg)))
  (setq alchemist-iex-buffer
        (apply 'make-comint "Alchemist-IEx" (car command) nil (cdr command)))
  (with-current-buffer alchemist-iex-buffer
    (alchemist-iex-mode)
    (run-hooks 'alchemist-iex-mode-hook)))

(defun alchemist-iex-process (&optional arg)
  (or (if (buffer-live-p alchemist-iex-buffer)
          (get-buffer-process alchemist-iex-buffer))
      (progn
        (let ((current-prefix-arg arg))
          (call-interactively 'alchemist-iex-start-process))
        (alchemist-iex-process arg))))

(defun alchemist-iex--remove-newlines (string)
  (replace-regexp-in-string "\n" " " string))

(defun alchemist-iex-send-last-sexp ()
  "Send the previous sexp to the inferior IEx process."
  (interactive)
  (alchemist-iex-send-region (save-excursion (backward-sexp) (point)) (point)))

(defun alchemist-iex-send-current-line ()
  "Sends the current line to the IEx process."
  (interactive)
  (let ((str (thing-at-point 'line)))
    (alchemist-iex--send-command (alchemist-iex-process) str)))

(defun alchemist-iex-send-current-line-and-go ()
  "Sends the current line to the inferior IEx process
and jump to the buffer."
  (interactive)
  (call-interactively 'alchemist-iex-send-current-line)
  (pop-to-buffer (process-buffer (alchemist-iex-process))))

(defun alchemist-iex-send-region-and-go ()
  "Sends the marked region to the inferior IEx process
and jump to the buffer."
  (interactive)
  (call-interactively 'alchemist-iex-send-region)
  (pop-to-buffer (process-buffer (alchemist-iex-process))))

(defun alchemist-iex-send-region (beg end)
  "Sends the marked region to the IEx process."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let* ((region (buffer-substring-no-properties beg end)))
    (alchemist-iex--send-command (alchemist-iex-process) region)))

(defun alchemist-iex-compile-this-buffer ()
  "Compiles the current buffer in the IEx process."
  (interactive)
  (let* ((path (if (alchemist-project-p)
		   (format "%s/_build/dev/" (alchemist-project-root))
		 "."))
	 (str (format "c(\"%s\", \"%s\")" (buffer-file-name) path)))
    (alchemist-iex--send-command (alchemist-iex-process) str)))

(defun alchemist-iex-compile-this-buffer-and-go ()
  "Compiles the current buffer in the IEx process and jump to the buffer."
  (interactive)
  (alchemist-iex-compile-this-buffer)
  (pop-to-buffer (process-buffer (alchemist-iex-process))))

(defun alchemist-iex-reload-module ()
  "Recompiles and reloads the current module in the IEx process."
  (interactive)
  (let ((str (format "r(%s)" (alchemist-scope-module))))
    (alchemist-iex--send-command (alchemist-iex-process) str)))

(defun alchemist-iex--send-command (proc str)
  (let ((lines (split-string str "\n" nil)))
    (with-current-buffer (process-buffer proc)
      (-map (lambda (line)
              (goto-char (process-mark proc))
              (insert-before-markers (concat line "\n"))
              (move-marker comint-last-input-end (point))
              (comint-send-string proc (concat line "\n"))) lines))))

(defun alchemist-iex-spot-prompt (_string)
  (let ((proc (get-buffer-process (current-buffer))))
    (when proc
      (save-excursion
        (goto-char (process-mark proc))))))

(defun alchemist-iex-clear-buffer ()
  "Clear the current iex process buffer."
  (interactive)
  (let ((comint-buffer-maximum-size 0))
    (comint-truncate-buffer)))

(defun alchemist-iex-open-input-ring ()
    "Open the buffer containing the input history."
    (interactive)
    (progn
      (comint-dynamic-list-input-ring)
      (other-window 1)))

;;;###autoload
(defalias 'run-elixir 'alchemist-iex-run)
(defalias 'inferior-elixir 'alchemist-iex-run)

;;;###autoload
(defun alchemist-iex-run (&optional arg)
  "Start an IEx process.
Show the IEx buffer if an IEx process is already run."
  (interactive "P")
  (let ((proc (alchemist-iex-process arg)))
    (pop-to-buffer (process-buffer proc))))

;;;###autoload
(defun alchemist-iex-project-run ()
  "Start an IEx process with mix 'iex -S mix' in the
context of an Elixir project.
Show the IEx buffer if an IEx process is already run."
  (interactive)
  (if (alchemist-project-p)
      (let ((default-directory (alchemist-project-root)))
        (pop-to-buffer (process-buffer (alchemist-iex-process " -S mix"))))
    (message "No mix.exs file available. Please use `alchemist-iex-run' instead.")))

(provide 'alchemist-iex)

;;; alchemist-iex.el ends here
alchemist-20180312.1304/alchemist-hex.el0000664000175000017500000003241014133447044016064 0ustar  kimrkimr;;; alchemist-hex.el --- Interface to the Hex package manager API. -*- lexical-binding: t -*-

;; Copyright © 2014-2016 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:

;;  Interface to the Hex package manager API.

;;; Code:

(require 'json)
(require 'dash)

(defgroup alchemist-hex nil
  "Interface to the Hex package manager API."
  :prefix "alchemist-test-mode-"
  :group 'alchemist)

(defconst alchemist-hex-api-url "https://hex.pm/api/packages/"
  "Hex package manager API url.")

(defconst alchemist-hexdoc-url "https://hexdocs.pm"
  "Hexdocs url.")

(defconst alchemist-hex-buffer-name "*alchemist-hex*"
  "Name of the hex output buffer.")

(defvar alchemist-hex-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "q" #'quit-window)
    map))

(defun alchemist-hex--fetch-package-info (pkg-name)
  (let* ((inhibit-message t)
         (url (concat alchemist-hex-api-url pkg-name))
         (string
          (with-current-buffer (url-retrieve-synchronously url t)
	    (goto-char (point-min))
	    (search-forward "\n\n")
	    (delete-region (point-min) (point))
            (buffer-string))))
    (when (string-match-p "\"status\":404" string)
      (error (format "There is no hex package [%s] available" pkg-name)))
    (json-read-from-string string)))

(defun alchemist-hex--fetch-search-packages (pkg-name)
  (let* ((inhibit-message t)
         (url (concat alchemist-hex-api-url "?search=" pkg-name))
         (string
          (with-current-buffer (url-retrieve-synchronously url t)
            (goto-char (point-min))
            (search-forward "\n\n")
            (delete-region (point-min) (point))
            (buffer-string))))
    (json-read-from-string string)))

(defun alchemist-hex--deps-name-at-point ()
  "Return the dependency name under the cursor."
  (let (p1 p2)
    (save-excursion
      (skip-chars-backward "-_a-z0-9")
      (setq p1 (point))
      (skip-chars-forward "-_a-z0-9")
      (setq p2 (point))
      (buffer-substring-no-properties p1 p2))))

(defun alchemist-hex--display-releases-for (package-name)
  (let* ((infos (alchemist-hex--fetch-package-info package-name))
         (releases (cdr (assoc 'releases infos)))
         (latest-version (cdr (assoc 'version (aref releases 0))))
         (latest-version-url (cdr (assoc 'url (aref releases 0))))
         (buffer (get-buffer-create alchemist-hex-buffer-name)))
    (with-current-buffer buffer
      (let ((inhibit-read-only t))
        (goto-char (point-min))
        (erase-buffer)
        (insert (propertize (format "%s versions  (latest version " package-name)
                            'face font-lock-variable-name-face))
        (insert-button latest-version
                       'action (lambda (x) (browse-url (button-get x 'url)))
                       'url (replace-regexp-in-string "\\(api/\\|releases/\\)" "" latest-version-url))
        (insert ")\n\n")
        (-map (lambda (release)
                (let ((version (cdr (assoc 'version release)))
                      (url (cdr (assoc 'url release)))
                      (date (date-to-time (cdr (assoc 'inserted_at release)))))
                  (insert-button version
                                 'action (lambda (x) (browse-url (button-get x 'url)))
                                 'url (replace-regexp-in-string "\\(api/\\|releases/\\)" "" url))
                  (insert (format "     (%s %s)"
                                  (propertize "released on" 'face font-lock-string-face)
                                  (format-time-string "%Y-%m-%d" date)))
                  (insert "   (")
                  (insert-button "docs"
                                 'face font-lock-constant-face
                                 'action (lambda (x) (browse-url (button-get x 'url)))
                                 'url (format "%s/%s/%s" alchemist-hexdoc-url package-name version))
                  (insert ")\n"))) releases)
        (align-regexp (point-min) (point-max) (concat "\\(\\s-*\\)" "    (") 1 1 t)
        (goto-char (point-min))
        (alchemist-hex-mode)))
    (pop-to-buffer buffer)))

(defun alchemist-hex--display-info-for (package-name)
  (let* ((infos (alchemist-hex--fetch-package-info package-name))
         (releases (cdr (assoc 'releases infos)))
         (latest-release (cdr (assoc 'version (aref releases 0))))
         (meta (assoc 'meta infos))
         (buffer (get-buffer-create alchemist-hex-buffer-name)))
    (with-current-buffer buffer
      (let ((inhibit-read-only t)
            (latest-version (cdr (assoc 'version (aref releases 0))))
            (latest-version-url (cdr (assoc 'url (aref releases 0)))))
        (goto-char (point-min))
        (erase-buffer)
        (insert (cdr (assoc 'description meta)))
        (insert "\n\n")
        (insert (propertize "Config: "
                            'face font-lock-string-face))
        (insert (format "{:%s, => \"~> %s\"}" package-name latest-release))
        (insert "\n")
        (insert (propertize "Latest release: " 'face font-lock-string-face))
        (insert-button latest-version
                       'action (lambda (x) (browse-url (button-get x 'url)))
                       'url (replace-regexp-in-string "\\(api/\\|releases/\\)" "" latest-version-url))
        (insert "\n\n")
        (insert (propertize "Maintainers: " 'face font-lock-string-face))
        (-map (lambda (maintainer)
                  (insert (format "\n  - %s" (decode-coding-string maintainer 'utf-8-auto)))
                  ) (cdr (assoc 'maintainers meta)))
        (insert "\n")
        (insert (propertize "Licenses: " 'face font-lock-string-face))
        (-map (lambda (license)
                  (insert (format "%s" (decode-coding-string license 'utf-8-auto)))
                ) (cdr (assoc 'licenses meta)))
        (insert "\n")
        (insert (propertize "Links: " 'face font-lock-string-face))
        (-map (lambda (link)
                (let ((link-name (car link))
                      (url (decode-coding-string (cdr link) 'utf-8-auto)))
                  (insert (format "\n  %s: " link-name))
                  (insert-button url
                                 'action (lambda (x) (browse-url (button-get x 'url)))
                                 'url url))) (cdr (assoc 'links meta)))
        (insert "\n")
        (insert (propertize "Releases: \n" 'face font-lock-string-face))
        (-map (lambda (release)
                (let ((version (cdr (assoc 'version release)))
                      (url (cdr (assoc 'url release))))
                (insert "  - ")
                (insert-button version
                               'action (lambda (x) (browse-url (button-get x 'url)))
                               'url (replace-regexp-in-string "\\(api/\\|releases/\\)" "" url))
                (insert "     (")
                (insert-button "docs"
                               'face font-lock-constant-face
                               'action (lambda (x) (browse-url (button-get x 'url)))
                               'url (format "%s/%s/%s" alchemist-hexdoc-url package-name version))
                (insert ")\n"))) releases)
        (align-regexp (point-min) (point-max) (concat "\\(\\s-*\\)" "     (") 1 1 t)
        (goto-char (point-min))
        (alchemist-hex-mode)))
    (pop-to-buffer buffer)))

(defun alchemist-hex-search (package-name)
  "Search for Hex packages."
  (interactive "Mhex search: \n")
  (let* ((packages (alchemist-hex--fetch-search-packages package-name))
         (buffer (get-buffer-create alchemist-hex-buffer-name)))
    (with-current-buffer buffer
      (let ((inhibit-read-only t))
        (goto-char (point-min))
        (erase-buffer)
        (insert (propertize "search results for: "
                            'face font-lock-variable-name-face))
        (insert (propertize (format "%s \n\n" package-name)
                            'face font-lock-builtin-face))
        (-map (lambda (package)
                (let ((name (cdr (assoc 'name package)))
                      (date (date-to-time (cdr (assoc 'inserted_at package))))
                      (version (cdr (assoc 'version (aref (cdr (assoc 'releases package)) 0))))
                      (url (cdr (assoc 'url package)))
                      (latest-release-url (cdr (assoc 'url (aref (cdr (assoc 'releases package)) 0)))))
                  (when (string-match-p package-name name)
                    (insert-button name
                                   'action (lambda (x) (browse-url (button-get x 'url)))
                                   'url url)
                    (insert "   ")
                    (insert-button version
                                   'action (lambda (x) (browse-url (button-get x 'url)))
                                   'url (replace-regexp-in-string "\\(api/\\|releases/\\)" "" latest-release-url))

                    (insert (format "     (%s %s)"
                                    (propertize "released on" 'face font-lock-string-face)
                                    (format-time-string "%Y-%m-%d" date)))
                    (insert "   (")
                    (insert-button "docs"
                                   'face font-lock-constant-face
                                   'action (lambda (x) (browse-url (button-get x 'url)))
                                   'url (format "%s/%s/%s" alchemist-hexdoc-url name version))
                    (insert ")\n")
                    (align-regexp (point-min) (point-max) (concat "\\(\\s-*\\)" "  ") 1 1 t))))
              packages)
        (goto-char (point-min))
        (alchemist-hex-mode)))
    (pop-to-buffer buffer)))

(defun alchemist-hex-all-dependencies ()
  "Display Hex package dependencies for the current Mix project."
  (interactive)
  (unless (alchemist-project-p)
    (error "No 'mix.exs' file exists."))
  (let* ((mix-content
          (with-temp-buffer
            (insert-file-contents (concat (alchemist-project-root) "mix.exs"))
            (goto-char (point-min))
            (delete-matching-lines "#")
            (buffer-string)))
         (deps-start (with-temp-buffer
                       (insert mix-content)
                       (goto-char (point-min))
                       (search-forward "defp deps do")))
         (deps-end (with-temp-buffer
                     (insert mix-content)
                     (goto-char deps-start)
                     (search-forward "end")))
         (deps (substring mix-content deps-start (- deps-end 4)))
         (deps (replace-regexp-in-string "\\(\\[\\|\\]\\)" "" deps))
         (deps (split-string deps "}\s*,"))
         (deps (-map (lambda (dep)
                       (replace-regexp-in-string "\\(\{\\|\}\\|\n\\|^\s*\\)" "" dep))
                     deps))
         (deps (-sort 'equal deps)))
    (unless (string-match-p "\s*defp? deps do" mix-content)
      (error "No dependency informations available in 'mix.exs'."))
    (let* ((content (with-temp-buffer
                      (goto-char (point-min))
                      (erase-buffer)
                      (-map (lambda (dep)
                              (insert dep)
                              (insert "\n")) deps)
                      (goto-char (point-min))
                      (align-regexp (point-min) (point-max) (concat "\\(\\s-*\\)" ", ") 1 1 t)
                      (while (search-forward ", " nil t)
                        (replace-match " " nil t))
                      (sort-lines nil (point-min) (point-max))
                      (buffer-string))))
      (alchemist-interact-create-popup alchemist-hex-buffer-name
                                       content
                                       #'(lambda ()
                                           (elixir-mode)
                                           (alchemist-hex-mode))))))

(defun alchemist-hex-info-at-point ()
  "Display Hex package information for the package at point."
  (interactive)
  (alchemist-hex--display-info-for (alchemist-hex--deps-name-at-point)))

(defun alchemist-hex-releases-at-point ()
  "Display Hex package releases for the package at point."
  (interactive)
  (alchemist-hex--display-releases-for (alchemist-hex--deps-name-at-point)))

(defun alchemist-hex-releases (package-name)
  "Display Hex package releases for a certain package."
  (interactive "Mhex releases: \n")
  (alchemist-hex--display-releases-for package-name))

(defun alchemist-hex-info (package-name)
  "Display Hex package info for a certain package."
  (interactive "Mhex info: \n")
  (alchemist-hex--display-info-for package-name))

(define-minor-mode alchemist-hex-mode
  "Minor mode for displaying Hex package manager informations.

\\{alchemist-hex-mode-map}"
  nil
  "Alchemist-Hex"
  alchemist-hex-mode-map
  (setq buffer-read-only t))

(provide 'alchemist-hex)

;;; alchemist-hex.el ends here
alchemist-20180312.1304/alchemist-server/0000775000175000017500000000000014133447044016264 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/.travis.yml0000664000175000017500000000031514133447044020374 0ustar  kimrkimrlanguage: elixir
elixir:
  - 1.1.1
  - 1.2.0-rc.0
  - 1.3.3
otp_release:
  - 18.0
  - 19.0
sudo: false
install: mix local.hex --force
script:
  - make
notifications:
  irc: "irc.freenode.org#emacs-elixir"
alchemist-20180312.1304/alchemist-server/run.exs0000664000175000017500000000012314133447044017605 0ustar  kimrkimrCode.require_file "lib/server.exs", __DIR__

Alchemist.Server.start([System.argv])
alchemist-20180312.1304/alchemist-server/.gitignore0000664000175000017500000000002214133447044020246 0ustar  kimrkimrtest/sandbox
.caskalchemist-20180312.1304/alchemist-server/test/0000775000175000017500000000000014133447044017243 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/test/helpers/0000775000175000017500000000000014133447044020705 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/test/helpers/complete_test.exs0000664000175000017500000000304314133447044024275 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/helpers/complete.exs", __DIR__

defmodule CompleteTest do
  use ExUnit.Case, async: true

  import Alchemist.Helpers.Complete

  defmodule MyModule do
    def say_hi, do: true
  end

  test "return completion candidates for 'List'" do
    assert run('List') == ['List.', 'Chars', 'first/1', 'last/1', 'to_atom/1',
                           'to_existing_atom/1', 'to_float/1', 'to_string/1', 'to_tuple/1',
                           'wrap/1', 'zip/1', 'delete/2', 'delete_at/2', 'duplicate/2',
                           'keysort/2', 'myers_difference/2', 'flatten/1', 'flatten/2', 'to_integer/1',
                           'to_integer/2', 'foldl/3', 'foldr/3', 'insert_at/3', 'keydelete/3',
                           'keymember?/3', 'keytake/3', 'pop_at/3', 'replace_at/3', 'update_at/3',
                           'keyfind/4', 'keyreplace/4', 'keystore/4']
  end

  test "return completion candidates for 'Str'" do
    assert run('Str') == ['Str', 'Stream', 'String', 'StringIO']
  end

  test "return completion candidates for 'List.del'" do
    assert run('List.del') == ['List.delete', 'delete/2', 'delete_at/2']
  end

  test "return completion candidates for module with alias" do
    Application.put_env(:"alchemist.el", :aliases, [{MyList, List}])

    assert run('MyList.del') == ['MyList.delete', 'delete/2', 'delete_at/2']
  end

  test "return completion candidates for functions from import" do
    imports = [MyModule]
    assert run('say', imports) == ["say_hi/0"]
  end
end
alchemist-20180312.1304/alchemist-server/test/helpers/process_commands_test.exs0000664000175000017500000000741314133447044026031 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/helpers/process_commands.exs", __DIR__

defmodule ServerTest do
  use ExUnit.Case
  import ExUnit.CaptureIO

  setup_all do
    on_exit fn ->
      {_status, files} = File.ls Path.expand("../fixtures", __DIR__)
      files |> Enum.each(fn(file) ->
        unless file == ".gitkeep" do
          File.rm Path.expand("../fixtures/#{file}", __DIR__)
        end
      end)
    end
  end

  test "Expression completion" do
    assert send_signal("COMP { 'def', [context: Elixir, imports: [], aliases: []]}") =~ """
    defoverridable/1
    """
  end

  test "Documentation lookup" do
    assert send_signal("DOCL { 'List', [context: Elixir, imports: [], aliases: []]}") =~ """
    \e[0m\n\e[7m\e[33m                                      List                                      \e[0m\n\e[0m
    """
  end

  test "Getting the definition source file information of code" do
    assert send_signal("DEFL {\"List,delete\", [context: Elixir, imports: [], aliases: []]}") =~ "/lib/elixir/lib/list.ex"
  end

  test "Evaluate the content of a file" do
    filename = Path.expand("../fixtures/eval_fixture.exs", __DIR__)
    File.write(filename, "1+1")
    assert send_signal("EVAL { :eval, '#{filename}' }") =~ "2"
  end

  test "Evaluate and quote the content of a file" do
    filename = Path.expand("../fixtures/eval_and_quote_fixture.exs", __DIR__)
    File.write(filename, "[4,2,1,3] |> Enum.sort")
    assert send_signal("EVAL { :quote, '#{filename}' }") =~ """
    {{:., [line: 1], [{:__aliases__, [counter: 0, line: 1], [:Enum]}, :sort]},\n   [line: 1], []}]}
    """
  end

  test "Expand macro once" do
    filename = Path.expand("../fixtures/macro_expand_once_fixture.exs", __DIR__)
    File.write(filename, "unless true, do: IO.puts \"this should never be printed\"")
    assert send_signal("EVAL { :expand_once, '#{filename}' }") =~ """
    if(true) do
      nil
    else
      IO.puts("this should never be printed")
    end
    """
  end

  test "Expand macro" do
    filename = Path.expand("../fixtures/macro_expand_fixture.exs", __DIR__)
    File.write(filename, "unless true, do: IO.puts \"this should never be printed\"")
    assert send_signal("EVAL { :expand, '#{filename}' }") =~ """
    case(true) do
      x when x in [false, nil] ->
        IO.puts("this should never be printed")
      _ ->
        nil
    end
    """
  end

  test "Get all available application modules" do
    assert send_signal("INFO { :type, :modules }") =~ """
    Elixir.Logger
    Elixir.Logger.Formatter
    Elixir.Logger.Translator
    """
  end

  test "Get all available mix tasks by name" do
    assert send_signal("INFO { :type, :mixtasks }") =~ """
    clean
    cmd
    compile
    """
  end

  # The IEx.Helpers.t and IEx.Helpers.i are functionality which come with
  # Elixir version 1.2.0
  if Version.match?(System.version, ">=1.2.0-rc") do
    test "Get information from data type" do
      assert send_signal("INFO { :type, :info, List}") =~ """
      END-OF-INFO
      """
    end

    test "Don't crash server if data type argument is faulty" do
      assert send_signal("INFO { :type, :info, whatever()}") =~ """
      END-OF-INFO
      """
    end

    test "Prints the types for the given module or for the given function/arity pair" do
      assert send_signal("INFO { :type, :types, 'Agent'}") =~ """
      @type agent() :: pid() | {atom(), node()} | name()\e[0m\n\e[22m@type state() :: term()\e[0m\nEND-OF-INFO
      """

      assert send_signal("INFO { :type, :types, 'Agent.on_start/0'}") =~ """
      @type on_start() :: {:ok, pid()} | {:error, {:already_started, pid()} | term()}\e[0m
      """
    end
  end

  defp send_signal(signal) do
    capture_io(fn ->
      Alchemist.Helpers.ProcessCommands.process(signal, "env") |> IO.write
    end)
  end
end
alchemist-20180312.1304/alchemist-server/test/helpers/module_info_test.exs0000664000175000017500000000247014133447044024770 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/helpers/module_info.exs", __DIR__

defmodule Alchemist.Helpers.ModuleTest do

  use ExUnit.Case

  alias Alchemist.Helpers.ModuleInfo

  test "moduledoc? returns true" do
    assert ModuleInfo.moduledoc?(List) == true
  end

  test "moduledoc? returns false" do
    assert ModuleInfo.moduledoc?(List.Chars.Atom) == false
  end

  test "docs? returns true" do
    assert ModuleInfo.docs?(List, :flatten) == true
    assert ModuleInfo.docs?(Kernel, :def) == true
  end

  test "docs? returns false" do
    assert ModuleInfo.docs?(List, :dance) == false
    assert ModuleInfo.docs?(nil, :dance) == false
  end

  test "expand_alias return expanded module alias" do
    aliases = [{MyList, List}, {MyGenServer, :gen_server}]

    assert ModuleInfo.expand_alias([MyList], aliases) == List
    assert ModuleInfo.expand_alias([MyGenServer], aliases) == :gen_server
    assert ModuleInfo.expand_alias([MyList], aliases) == List
  end

  test "has_function? return true" do
    assert ModuleInfo.has_function?(List, :flatten) == true
    assert ModuleInfo.has_function?(List, :to_string) == true
  end

  test "has_function? return false" do
    assert ModuleInfo.has_function?(List, :split) == false
    assert ModuleInfo.has_function?(List, :map) == false
  end
end
alchemist-20180312.1304/alchemist-server/test/api/0000775000175000017500000000000014133447044020014 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/test/api/docl_test.exs0000664000175000017500000000367114133447044022524 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/api/comp.exs", __DIR__
Code.require_file "../../lib/api/docl.exs", __DIR__

defmodule Alchemist.API.DoclTest do

  use ExUnit.Case, async: true

  alias Alchemist.API.Docl

  test "DOCL full request" do
    docl_resp = Docl.request(~s({ "defmodule", [ context: Elixir, imports: [], aliases: [] ] }))
    assert docl_resp =~ """
    Defines a module given by name with the given contents.
    """
    assert docl_resp =~ ~r"END-OF-DOCL$"
  end

  test "DOCL request" do
    assert Docl.process(['defmodule', [], []]) =~ """
    Defines a module given by name with the given contents.
    """
  end

  test "DOCL request with no match" do
    assert Docl.process(['FooBar', [], []]) =~ "Could not load module FooBar"
  end


  test "DOCL request for List.flatten" do
    assert Docl.process(["List.flatten", [], []]) =~ """
    Flattens the given \e[36mlist\e[0m of nested lists.
    """
  end

  test "DOCL request for MyCustomList.flatten with alias" do
    assert Docl.process(["MyCustomList.flatten", [], [{MyCustomList, List}]]) =~ """
    Flattens the given \e[36mlist\e[0m of nested lists.
    """
  end

  test "DOCL request for search create_file with import" do
    assert Docl.process(["create_file", [Mix.Generator], []]) =~ """
    def create_file(path, contents, opts \\\\ [])                   \e[0m
    \e[0m
    Creates a file with the given contents. If the file already exists, asks for
    user confirmation.
    \e[0m
    """
  end

  test "DOCL request for defmacro" do
    assert Docl.process(["defmacro", [], []]) =~ """
    \e[7m\e[33m                      defmacro defmacro(call, expr \\\\ nil)                      \e[0m
    """
  end

  test "DOCL request for Path.basename/1" do
    assert Docl.process(["Path.basename/1", [], []]) =~ """
    Returns the last component of the path or the path itself if it does not
    contain any directory separators.
    """
  end

end
alchemist-20180312.1304/alchemist-server/test/api/ping_test.exs0000664000175000017500000000045114133447044022531 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/api/ping.exs", __DIR__

defmodule Alchemist.API.PingTest do

  use ExUnit.Case, async: true

  alias Alchemist.API.Ping

  test "PING request" do
    assert Ping.request =~ """
    PONG
    END-OF-PING
    """
  end
end
alchemist-20180312.1304/alchemist-server/test/api/defl_test.exs0000664000175000017500000000312214133447044022504 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/api/defl.exs", __DIR__

defmodule Alchemist.API.DeflTest do

  use ExUnit.Case

  alias Alchemist.API.Defl

  test "DEFL request call for defmodule" do
    context = [context: Elixir, imports: [], aliases: []]
    assert Defl.process([nil, :defmodule, context]) =~ "lib/elixir/lib/kernel.ex"
  end

  test "DEFL request call for import" do
    context = [context: Elixir, imports: [], aliases: []]
    assert Defl.process([nil, :import, context]) =~ "lib/elixir/lib/kernel/special_forms.ex"
  end

  test "DEFL request call for create_file with available import" do
    context = [context: Elixir, imports: [Mix.Generator], aliases: []]
    assert Defl.process([nil, :create_file, context]) =~ "lib/mix/lib/mix/generator.ex"
  end

  test "DEFL request call for MyList.flatten with available aliases" do
    context = [context: Elixir, imports: [], aliases: [{MyList, List}]]
    assert Defl.process([MyList, :flatten, context]) =~ "lib/elixir/lib/list.ex"
  end

  test "DEFL request call for String module" do
    context = [context: Elixir, imports: [], aliases: []]
    assert Defl.process([String, nil, context]) =~ "lib/elixir/lib/string.ex"
  end

  test "DEFL request call for erlang module" do
    context = [ context: Elixir, imports: [], aliases: [] ]
    assert Defl.process([:lists, :duplicate, context]) =~ "lib/stdlib/src/lists.erl"
  end

  test "DEFL request call for none existing module" do
    context = [ context: Elixir, imports: [], aliases: [] ]
    assert Defl.process([Rock, :duplicate, context]) == nil
  end

end
alchemist-20180312.1304/alchemist-server/test/api/comp_test.exs0000664000175000017500000000227714133447044022542 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/api/comp.exs", __DIR__

defmodule Alchemist.API.CompTest do

  use ExUnit.Case, async: true

  alias Alchemist.API.Comp

  test "COMP request with empty hint" do
    assert Comp.process([nil, Elixir, [], [] ]) =~ """
    import/2
    quote/2
    require/2
    END-OF-COMP
    """
  end

  test "COMP request without empty hint" do
    assert Comp.process(['is_b', Elixir, [], []]) =~ """
    is_b
    is_binary/1
    is_bitstring/1
    is_boolean/1
    END-OF-COMP
    """
  end

  test "COMP request with an alias" do
    assert Comp.process(['MyList.flat', Elixir, [], [{MyList, List}]]) =~ """
    MyList.flatten
    flatten/1
    flatten/2
    END-OF-COMP
    """
  end

  test "COMP request with a module hint" do
    assert Comp.process(['Str', Elixir, [], []]) =~ """
    Str
    Stream
    String
    StringIO
    END-OF-COMP
    """
  end

  test "return redundant candidates with COMP" do
    assert Comp.process(['Enu', Elixir, [], []]) =~ """
    Enum
    Enum
    Enumerable
    END-OF-COMP
    """
  end

  test "COMP request with no match" do
    assert Comp.process(['Fooo', Elixir, [], []]) == "END-OF-COMP\n"
  end

end
alchemist-20180312.1304/alchemist-server/test/server/0000775000175000017500000000000014133447044020551 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/test/server/socket_test.exs0000664000175000017500000000145314133447044023624 0ustar  kimrkimrCode.require_file "../test_helper.exs", __DIR__
Code.require_file "../../lib/server/socket.exs", __DIR__

defmodule Alchemist.Server.SocketTest do
  use ExUnit.Case

  alias Alchemist.Server.Socket, as: ServerSocket

  setup do
    ServerSocket.start([env: "dev", port: 55293])
    :ok
  end

  setup do
    opts = [:binary, packet: :line, active: false]
    {:ok, socket} = :gen_tcp.connect('localhost', 55293, opts)
    {:ok, socket: socket}
  end

  test "server reply ping", %{socket: socket} do
    assert send_and_recv(socket, "PING\n", 2) == "PONG\nEND-OF-PING\n"
  end

  defp send_and_recv(socket, command, num_lines) do
    :ok = :gen_tcp.send(socket, command)
    result = for _ <- 1..num_lines do
      {:ok, data} = :gen_tcp.recv(socket, 0, 1000)
      data
    end
    Enum.join(result)
  end
end
alchemist-20180312.1304/alchemist-server/test/server_test.exs0000664000175000017500000000750714133447044022342 0ustar  kimrkimrCode.require_file "test_helper.exs", __DIR__
Code.require_file "../lib/server.exs", __DIR__

defmodule ServerTest do
  use ExUnit.Case
  import ExUnit.CaptureIO

  setup_all do
    on_exit fn ->
      {_status, files} = File.ls Path.expand("fixtures", __DIR__)
      files |> Enum.each(fn(file) ->
        unless file == ".gitkeep" do
          File.rm Path.expand("fixtures/#{file}", __DIR__)
        end
      end)
    end
  end

  test "Expression completion" do
    assert send_signal("COMP { 'def', [context: Elixir, imports: [], aliases: []]}") =~ """
    defoverridable/1
    """
  end

  test "Documentation lookup" do
    assert send_signal("DOCL { 'List', [context: Elixir, imports: [], aliases: []]}") =~ """
    \e[0m\n\e[7m\e[33m                                      List                                      \e[0m\n\e[0m
    """
  end

  test "Getting the definition source file information of code" do
    assert send_signal("DEFL {\"List,delete\", [context: Elixir, imports: [], aliases: []]}") =~ "/lib/elixir/lib/list.ex"
  end

  test "Evaluate the content of a file" do
    filename = Path.expand("fixtures/eval_fixture.exs", __DIR__)
    File.write(filename, "1+1")
    assert send_signal("EVAL { :eval, '#{filename}' }") =~ "2"
  end

  test "Evaluate and quote the content of a file" do
    filename = Path.expand("fixtures/eval_and_quote_fixture.exs", __DIR__)
    File.write(filename, "[4,2,1,3] |> Enum.sort")
    assert send_signal("EVAL { :quote, '#{filename}' }") =~ """
    {{:., [line: 1], [{:__aliases__, [counter: 0, line: 1], [:Enum]}, :sort]},\n   [line: 1], []}]}
    """
  end

  test "Expand macro once" do
    filename = Path.expand("fixtures/macro_expand_once_fixture.exs", __DIR__)
    File.write(filename, "unless true, do: IO.puts \"this should never be printed\"")
    assert send_signal("EVAL { :expand_once, '#{filename}' }") =~ """
    if(true) do
      nil
    else
      IO.puts("this should never be printed")
    end
    """
  end

  test "Expand macro" do
    filename = Path.expand("fixtures/macro_expand_fixture.exs", __DIR__)
    File.write(filename, "unless true, do: IO.puts \"this should never be printed\"")
    assert send_signal("EVAL { :expand, '#{filename}' }") =~ """
    case(true) do
      x when x in [false, nil] ->
        IO.puts("this should never be printed")
      _ ->
        nil
    end
    """
  end

  test "Get all available application modules" do
    assert send_signal("INFO { :type, :modules }") =~ """
    Elixir.Logger
    Elixir.Logger.Formatter
    Elixir.Logger.Translator
    """
  end

  test "Get all available mix tasks by name" do
    assert send_signal("INFO { :type, :mixtasks }") =~ """
    app.start
    archive
    archive.build
    archive.install
    archive.uninstall
    clean
    cmd
    compile
    """
  end

  # The IEx.Helpers.t and IEx.Helpers.i are functionality which come with
  # Elixir version 1.2.0
  if Version.match?(System.version, ">=1.2.0-rc") do
    test "Get information from data type" do
      assert send_signal("INFO { :type, :info, List}") =~ """
      Reference modules\e[0m\n\e[22m  Module, Atom\e[0m\nEND-OF-INFO
      """
    end

    test "Don't crash server if data type argument is faulty" do
      assert send_signal("INFO { :type, :info, whatever}") =~ """
      END-OF-INFO
      """
    end

    test "Prints the types for the given module or for the given function/arity pair" do
      assert send_signal("INFO { :type, :types, 'Agent'}") =~ """
      @type agent() :: pid() | {atom(), node()} | name()\e[0m\n\e[22m@type state() :: term()\e[0m\nEND-OF-INFO
      """

      assert send_signal("INFO { :type, :types, 'Agent.on_start/0'}") =~ """
      @type on_start() :: {:ok, pid()} | {:error, {:already_started, pid()} | term()}\e[0m
      """
    end
  end

  defp send_signal(signal) do
    capture_io(fn ->
      Alchemist.Server.read_input(signal)
    end)
  end
end
alchemist-20180312.1304/alchemist-server/test/test_helper.exs0000664000175000017500000000001714133447044022300 0ustar  kimrkimrExUnit.start()
alchemist-20180312.1304/alchemist-server/test/api_test.exs0000664000175000017500000000067014133447044021577 0ustar  kimrkimrCode.require_file "test_helper.exs", __DIR__
Code.require_file "../lib/api/comp.exs", __DIR__
Code.require_file "../lib/api/docl.exs", __DIR__

defmodule APITest do
  use ExUnit.Case, async: true
  import ExUnit.CaptureIO

  alias Alchemist.API

  test "DOCL request" do
    assert capture_io(fn ->
      API.Docl.process(['defmodule', [], []])
    end) =~ """
    Defines a module given by name with the given contents.
    """
  end

end
alchemist-20180312.1304/alchemist-server/test/fixtures/0000775000175000017500000000000014133447044021114 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/test/fixtures/.gitkeep0000664000175000017500000000000014133447044022533 0ustar  kimrkimralchemist-20180312.1304/alchemist-server/README.md0000664000175000017500000001014314133447044017542 0ustar  kimrkimr[![License GPL 3](https://img.shields.io/badge/license-GPL_3-green.svg)](http://www.gnu.org/licenses/gpl-3.0.txt)
[![Build Status](https://img.shields.io/travis/tonini/alchemist-server.svg)](https://travis-ci.org/tonini/alchemist-server)

**INFO:** The Alchemist-Server is in Beta status and the API will most likey change until the first release. Feedback and critic are highly appreciated though.

# Alchemist Server

The Alchemist-Server operates as an informant for a specific desired
Elixir Mix project and serves with informations as the following:

* Completion for Modules and functions.
* Documentation lookup for Modules and functions.
* Code evaluation and quoted representation of code.
* Definition lookup of code.
* Listing of all available Mix tasks.
* Listing of all available Modules with documentation.

# Usage

The server needs to be started inside an Elixir mix project, it can be started in two ways:

## Read/Write through `STDIN/STDOUT`
```
$ cd elixir_project
$ elixir path/to/alchemist-server/run.exs --env=dev
```
In this mode, when input sent to a running server process it
responds by sending information back to the `STDOUT`.

A request consisting of two parts, the request type and the request arguments.

Example for a completion request:

```
[type]   [arguments]

COMP { "def", [ context: Elixir, imports: [Enum], aliases: [{MyList, List}] ] }
```

## Read/Write through network socket
```
$ cd elixir_project
$ elixir path/to/alchemist-server/run.exs --env=dev --listen
ok|localhost:55580
```
In this mode, when a client connects to the port, it
responds by sending information back to the opened connection

Example for a completion request:

```
$ nc localhost 55580
COMP { "def", [ context: Elixir, imports: [Enum], aliases: [{MyList, List}] ] }
```

# API

## Completion

Return a completion list of all the available candidates.

```
COMP
COMP { "def", [ context: Elixir, imports: [], aliases: [] ] }
COMP { "List.fla", [ context: Elixir, imports: [], aliases: [] ] }
```

## Documentation lookup

Return the documentation.

```
DOCL { "defmodule", [ context: Elixir, imports: [], aliases: [] ] }
DOCL { "List.flatten/1", [ context: Elixir, imports: [], aliases: [] ] }
```

## Evaluation, Quoted & Macro expand

### Evaluation

Return the evaluation result of the code from the file.

```
EVAL { :eval, 'path/to/file/which/holds/content/to/eval.tmp' }
```

### Quoted

Return the code from the file quoted.

```
EVAL { :quote, 'path/to/file/which/holds/content/to/quote.tmp' }
```

### Macro expand

Return the code from the file expanded.

```
EVAL { :expand, 'path/to/file/which/holds/content/to/expand.tmp' }
```

Return the code from the file expanded once.

```
EVAL { :expand_once, 'path/to/file/which/holds/content/to/expand_once.tmp' }
```

## Definition lookup

Return the path to the source file which holds the definition.

```
DEFL  { "List,flatten", [ context: Elixir, imports: [], aliases: [] ] }
DEFL  { "nil,defmacro", [ context: Elixir, imports: [], aliases: [] ] }
DEFL  { "nil,create_file", [ context: Elixir, imports: [Mix.Generator], aliases: [] ] }
DEFL  { "MyList,nil", [ context: Elixir, imports: [], aliases: [{MyList, List}] ] }
```

## Informations

### Mix tasks

Return a list of all available mix tasks.

```
INFO { :type, :mixtasks }
```

### Modules

Return a list of all available modules which has documentation.

```
INFO { :type, :modules }
```

### Datatype Information

Return information about any datatype.

```
INFO { :type, :info, List }
```

### Module Or Function/Arity Types Information

Return types for a module or function/arity pair.

```
INFO { :type, :types, 'List' }
INFO { :type, :types, 'Enum.t' }
INFO { :type, :types, 'Agent.on_start/0' }
```

## Debugging

Return PONG as response, it can be used for purpose of debugging and checking server's availability.

```
PING
```

## End Markers

Each request type ends with a specific end marker tag to notify that the request is done.

An end tag looks like the following:

```
END-OF-<REQUEST TYPE>
```

For example, after the following request an end tag would look like this:

```
INFO { :type, :modules }
List
String
Enum
.
...
....
END-OF-INFO
```
alchemist-20180312.1304/alchemist-server/Makefile0000664000175000017500000000157414133447044017733 0ustar  kimrkimrELIXIR = elixir

VERSION = $(shell git describe --tags --abbrev=0 | sed 's/^v//')

NO_COLOR=\033[0m
INFO_COLOR=\033[2;32m
STAT_COLOR=\033[2;33m

all: test

test:
	${MAKE} test_servers
	${MAKE} test_helpers
	${MAKE} test_api

test_servers:
	@ echo "\n$(INFO_COLOR)Run server tests: $(NO_COLOR)\n"
	$(ELIXIR) test/server/socket_test.exs
test_helpers:
	@ echo "\n$(INFO_COLOR)Run helper tests: $(NO_COLOR)\n"
	$(ELIXIR) test/helpers/process_commands_test.exs
	$(ELIXIR) test/helpers/module_info_test.exs
	$(ELIXIR) test/helpers/complete_test.exs

test_api:
	@ echo "\n$(INFO_COLOR)Run api tests: $(NO_COLOR)\n"
	$(ELIXIR) test/api/docl_test.exs
	$(ELIXIR) test/api/comp_test.exs
	$(ELIXIR) test/api/defl_test.exs
	$(ELIXIR) test/api/ping_test.exs

api_completer:
	@ echo "\n$(INFO_COLOR)Run api tests: $(NO_COLOR)\n"
	$(ELIXIR) test/api_test.exs


.PHONY: test test_server test_helpers test_api
alchemist-20180312.1304/alchemist-server/lib/0000775000175000017500000000000014133447044017032 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/lib/helpers/0000775000175000017500000000000014133447044020474 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/lib/helpers/module_info.exs0000664000175000017500000000536514133447044023526 0ustar  kimrkimrdefmodule Alchemist.Helpers.ModuleInfo do

  @moduledoc false

  def moduledoc?(module) do
    case Code.get_docs module, :moduledoc do
      {_, doc} -> is_binary doc
      _ -> false
    end
  end

  def docs?(module, function) do
    docs = Code.get_docs module, :docs
    do_docs?(docs, function)
  end

  def expand_alias([name | rest] = list, aliases) do
    module = Module.concat(Elixir, name)
    Enum.find_value(aliases, list, fn {alias, mod} ->
      if alias === module do
        case Atom.to_string(mod) do
          "Elixir." <> mod ->
            Module.concat [mod|rest]
          _ ->
            mod
        end
      end
    end) |> normalize_module
  end

  def get_functions(module, hint) do
    hint        = to_string hint
    {module, _} = Code.eval_string(module)
    functions   = get_module_funs(module)

    list = Enum.reduce functions, [], fn({f, a}, acc) ->
      case :lists.keyfind(f, 1, acc) do
        {f, aa} -> :lists.keyreplace(f, 1, acc, {f, [a|aa]})
        false -> [{f, [a]}|acc]
      end
    end

    do_get_functions(list, hint) |> :lists.sort()
  end

  def has_function?(module, function) do
    List.keymember? get_module_funs(module), function, 0
  end

  defp do_get_functions(list, "") do
    all_functions(list)
  end

  defp do_get_functions(list, hint) do
    all_functions(list, hint)
  end

  defp get_module_funs(module) do
    case Code.ensure_loaded(module) do
      {:module, _} ->
        module.module_info(:functions) ++ module.__info__(:macros)
      _otherwise ->
        []
    end
  end

  defp all_functions(list) do
    for {fun, arities} <- list, name = Atom.to_string(fun) do
      "#{name}/#{List.first(arities)}"
    end
  end

  defp all_functions(list, hint) do
    for {fun, arities} <- list,
    name = Atom.to_string(fun),
    String.starts_with?(name, hint) do
      "#{name}/#{List.first(arities)}"
    end
  end

  def all_applications_modules do
    for [app] <- loaded_applications(),
    {:ok, modules} = :application.get_key(app, :modules),
    module <- modules do
      module
    end
  end

  defp do_docs?([head|tail], function) do
    {{func, _}, _, _, _, doc} = head
    if func == function and is_binary(doc) do
      true
    else
      do_docs?(tail, function)
    end
  end
  defp do_docs?([], _function), do: false
  defp do_docs?(nil, _function), do: false

  defp loaded_applications do
    # If we invoke :application.loaded_applications/0,
    # it can error if we don't call safe_fixtable before.
    # Since in both cases we are reaching over the
    # application controller internals, we choose to match
    # for performance.
    :ets.match(:ac_tab, {{:loaded, :"$1"}, :_})
  end

  defp normalize_module(mod) do
    if is_list(mod) do
      Module.concat(mod)
    else
      mod
    end
  end

end
alchemist-20180312.1304/alchemist-server/lib/helpers/capture_io.exs0000664000175000017500000000160714133447044023353 0ustar  kimrkimrdefmodule Alchemist.Helpers.CaptureIO do

  def capture_io(fun) do
    do_capture_io(:standard_io, [], fun)
  end

  defp do_capture_io(:standard_io, options, fun) do
    prompt_config = Keyword.get(options, :capture_prompt, true)
    input = Keyword.get(options, :input, "")

    original_gl = Process.group_leader()
    {:ok, capture_gl} = StringIO.open(input, capture_prompt: prompt_config)
    try do
      Process.group_leader(self(), capture_gl)
      do_capture_io(capture_gl, fun)
    after
      Process.group_leader(self(), original_gl)
    end
  end

  def do_capture_io(string_io, fun) do
    try do
       _ = fun.()
      :ok
    catch
      kind, reason ->
        stack = System.stacktrace()
        _ = StringIO.close(string_io)
        :erlang.raise(kind, reason, stack)
    else
      :ok ->
        {:ok, output} = StringIO.close(string_io)
        elem(output, 1)
    end
  end
end
alchemist-20180312.1304/alchemist-server/lib/helpers/process_commands.exs0000664000175000017500000000347714133447044024567 0ustar  kimrkimrCode.require_file "../api/comp.exs", __DIR__
Code.require_file "../api/docl.exs", __DIR__
Code.require_file "../api/defl.exs", __DIR__
Code.require_file "../api/eval.exs", __DIR__
Code.require_file "../api/info.exs", __DIR__
Code.require_file "../api/ping.exs", __DIR__
Code.require_file "../api/version.exs", __DIR__

defmodule Alchemist.Helpers.ProcessCommands do

  @moduledoc false

  alias Alchemist.API

  def process(line, env) do
    loaded = all_loaded()

    paths = load_paths(env)
    apps  = load_apps(env)

    result = execute_input(line)
    purge_modules(loaded)
    purge_paths(paths)
    purge_apps(apps)
    result
  end

  defp execute_input(line) do
    case line |> String.split(" ", parts: 2) do
      ["COMP", args] ->
        API.Comp.request(args)
      ["DOCL", args] ->
        API.Docl.request(args)
      ["INFO", args] ->
        API.Info.request(args)
      ["EVAL", args] ->
        API.Eval.request(args)
      ["DEFL", args] ->
        API.Defl.request(args)
      ["PING"] ->
        API.Ping.request()
      ["VERSION"] ->
        API.Version.request()
      _ ->
        nil
    end
  end

  defp all_loaded() do
    for {m,_} <- :code.all_loaded, do: m
  end

  defp load_paths(env) do
    for path <- Path.wildcard("_build/#{env}/lib/*/ebin") do
      Code.prepend_path(path)
      path
    end
  end

  defp load_apps(env) do
    for path <- Path.wildcard("_build/#{env}/lib/*/ebin/*.app") do
      app = path |> Path.basename() |> Path.rootname() |> String.to_atom
      Application.load(app)
      app
    end
  end

  defp purge_modules(loaded) do
    for m <- (all_loaded() -- loaded) do
      :code.delete(m)
      :code.purge(m)
    end
  end

  defp purge_paths(paths) do
    for p <- paths, do: Code.delete_path(p)
  end

  defp purge_apps(apps) do
    for a <- apps, do: Application.unload(a)
  end

end
alchemist-20180312.1304/alchemist-server/lib/helpers/complete.exs0000664000175000017500000002122414133447044023026 0ustar  kimrkimrCode.require_file "module_info.exs", __DIR__

defmodule Alchemist.Helpers.Complete do

  alias Alchemist.Helpers.ModuleInfo

  @moduledoc """
  This Alchemist.Completer holds a codebase copy of the
  IEx.Autocomplete because for the use of context specific
  aliases.

  With the release of Elixir v1.1 the IEx.Autocomplete will
  look for aliases in a certain environment variable
  `Application.get_env(:iex, :autocomplete_server)` and until
  then we'll use our own autocomplete codebase.
  """

  def run(exp) do
    code = case is_bitstring(exp) do
             true -> exp |> String.to_char_list
             _ -> exp
           end

    {status, result, list } = expand(code |> Enum.reverse)

    case { status, result, list } do
      { :no, _, _ }  -> ''
      { :yes, [], _ } -> List.insert_at(list, 0, exp)
      { :yes, _,  _ } -> run(code ++ result)
    end
  end

  def run(hint, modules) do
    for module <- modules do
      ModuleInfo.get_functions(module, hint)
    end |> List.flatten
  end

  def expand('') do
    expand_import("")
  end

  def expand([h|t]=expr) do
    cond do
      h === ?. and t != []->
        expand_dot(reduce(t))
      h === ?: ->
        expand_erlang_modules()
      identifier?(h) ->
        expand_expr(reduce(expr))
      (h == ?/) and t != [] and identifier?(hd(t)) ->
        expand_expr(reduce(t))
      h in '([{' ->
        expand('')
      true ->
        no()
    end
  end

  defp identifier?(h) do
    (h in ?a..?z) or (h in ?A..?Z) or (h in ?0..?9) or h in [?_, ??, ?!]
  end

  defp expand_dot(expr) do
    case Code.string_to_quoted expr do
      {:ok, atom} when is_atom(atom) ->
        expand_call(atom, "")
      {:ok, {:__aliases__, _, list}} ->
        expand_elixir_modules(list, "")
      _ ->
        no()
    end
  end

  defp expand_expr(expr) do
    case Code.string_to_quoted expr do
      {:ok, atom} when is_atom(atom) ->
        expand_erlang_modules(Atom.to_string(atom))
      {:ok, {atom, _, nil}} when is_atom(atom) ->
        expand_import(Atom.to_string(atom))
      {:ok, {:__aliases__, _, [root]}} ->
        expand_elixir_modules([], Atom.to_string(root))
      {:ok, {:__aliases__, _, [h|_] = list}} when is_atom(h) ->
        hint = Atom.to_string(List.last(list))
        list = Enum.take(list, length(list) - 1)
        expand_elixir_modules(list, hint)
      {:ok, {{:., _, [mod, fun]}, _, []}} when is_atom(fun) ->
        expand_call(mod, Atom.to_string(fun))
      _ ->
        no()
    end
  end

  defp reduce(expr) do
    Enum.reverse Enum.reduce ' ([{', expr, fn token, acc ->
      hd(:string.tokens(acc, [token]))
    end
  end

  defp yes(hint, entries) do
    {:yes, String.to_char_list(hint), Enum.map(entries, &String.to_char_list/1)}
  end

  defp no do
    {:no, '', []}
  end

  ## Formatting

  defp format_expansion([], _) do
    no()
  end

  defp format_expansion([uniq], hint) do
    case to_hint(uniq, hint) do
      ""   -> yes("", to_uniq_entries(uniq))
      hint -> yes(hint, [])
    end
  end

  defp format_expansion([first|_]=entries, hint) do
    binary = Enum.map(entries, &(&1.name))
    length = byte_size(hint)
    prefix = :binary.longest_common_prefix(binary)
    if prefix in [0, length] do
      yes("", Enum.flat_map(entries, &to_entries/1))
    else
      yes(:binary.part(first.name, prefix, length-prefix), [])
    end
  end

  ## Expand calls

  # :atom.fun
  defp expand_call(mod, hint) when is_atom(mod) do
    expand_require(mod, hint)
  end

  # Elixir.fun
  defp expand_call({:__aliases__, _, list}, hint) do
    expand_alias(list)
    |> normalize_module
    |> expand_require(hint)
  end

  defp expand_call(_, _) do
    no()
  end

  defp expand_require(mod, hint) do
    format_expansion match_module_funs(mod, hint), hint
  end

  defp expand_import(hint) do
    funs = match_module_funs(IEx.Helpers, hint) ++
      match_module_funs(Kernel, hint) ++
      match_module_funs(Kernel.SpecialForms, hint)
    format_expansion funs, hint
  end

  ## Erlang modules

  defp expand_erlang_modules(hint \\ "") do
    format_expansion match_erlang_modules(hint), hint
  end

  defp match_erlang_modules(hint) do
    for mod <- match_modules(hint, true) do
      %{kind: :module, name: mod, type: :erlang}
    end
  end

  ## Elixir modules

  defp expand_elixir_modules([], hint) do
    expand_elixir_modules(Elixir, hint, match_aliases(hint))
  end

  defp expand_elixir_modules(list, hint) do
    expand_alias(list)
    |> normalize_module
    |> expand_elixir_modules(hint, [])
  end

  defp expand_elixir_modules(mod, hint, aliases) do
    aliases
    |> Kernel.++(match_elixir_modules(mod, hint))
    |> Kernel.++(match_module_funs(mod, hint))
    |> format_expansion(hint)
  end

  defp expand_alias([name | rest] = list) do
    module = Module.concat(Elixir, name)
    Enum.find_value env_aliases(), list, fn {alias, mod} ->
      if alias === module do
        case Atom.to_string(mod) do
          "Elixir." <> mod ->
            Module.concat [mod|rest]
          _ ->
            mod
        end
      end
    end
  end

  defp env_aliases() do
    Application.get_env(:"alchemist.el", :aliases)
    |> format_aliases
  end

  defp format_aliases(nil), do: []
  defp format_aliases(list), do: list

  defp match_aliases(hint) do
    for {alias, _mod} <- env_aliases(),
    [name] = Module.split(alias),
    starts_with?(name, hint) do
      %{kind: :module, type: :alias, name: name}
    end
  end

  defp match_elixir_modules(module, hint) do
    name  = Atom.to_string(module)
    depth = length(String.split(name, ".")) + 1
    base  = name <> "." <> hint

    for mod <- match_modules(base, module === Elixir),
    parts = String.split(mod, "."),
    depth <= length(parts) do
      %{kind: :module, type: :elixir, name: Enum.at(parts, depth-1)}
    end
    |> Enum.uniq
  end

  ## Helpers

   defp normalize_module(mod) do
    if is_list(mod) do
      Module.concat(mod)
    else
      mod
    end
  end

  defp match_modules(hint, root) do
    get_modules(root)
    |> :lists.usort()
    |> Enum.drop_while(& not starts_with?(&1, hint))
    |> Enum.take_while(& starts_with?(&1, hint))
  end

  defp get_modules(true) do
    ["Elixir.Elixir"] ++ get_modules(false)
  end

  defp get_modules(false) do
    modules = Enum.map(:code.all_loaded(), &Atom.to_string(elem(&1, 0)))
    case :code.get_mode() do
      :interactive -> modules ++ get_modules_from_applications()
      _otherwise -> modules
    end
  end

  defp get_modules_from_applications do
    for [app] <- loaded_applications(),
    {:ok, modules} = :application.get_key(app, :modules),
    module <- modules do
      Atom.to_string(module)
    end
  end

  defp loaded_applications do
    # If we invoke :application.loaded_applications/0,
    # it can error if we don't call safe_fixtable before.
    # Since in both cases we are reaching over the
    # application controller internals, we choose to match
    # for performance.
    :ets.match(:ac_tab, {{:loaded, :"$1"}, :_})
  end

  defp match_module_funs(mod, hint) do
    case ensure_loaded(mod) do
      {:module, _} ->
        falist = get_module_funs(mod)

      list = Enum.reduce falist, [], fn {f, a}, acc ->
        case :lists.keyfind(f, 1, acc) do
          {f, aa} -> :lists.keyreplace(f, 1, acc, {f, [a|aa]})
          false -> [{f, [a]}|acc]
        end
      end

      for {fun, arities} <- list,
      name = Atom.to_string(fun),
      starts_with?(name, hint) do
        %{kind: :function, name: name, arities: arities}
      end |> :lists.sort()

      _otherwise -> []
    end
  end

  defp get_module_funs(mod) do
    if function_exported?(mod, :__info__, 1) do
      if docs = Code.get_docs(mod, :docs) do
        for {tuple, _line, _kind, _sign, doc} <- docs, doc != false, do: tuple
      else
        mod.__info__(:macros) ++ (mod.__info__(:functions) -- [__info__: 1])
      end
    else
      mod.module_info(:exports)
    end
  end

  defp ensure_loaded(Elixir), do: {:error, :nofile}
  defp ensure_loaded(mod), do: Code.ensure_compiled(mod)

  defp starts_with?(_string, ""),  do: true
  defp starts_with?(string, hint), do: String.starts_with?(string, hint)

  ## Ad-hoc conversions

  defp to_entries(%{kind: :module, name: name}) do
    [name]
  end

  defp to_entries(%{kind: :function, name: name, arities: arities}) do
    for a <- :lists.sort(arities), do: "#{name}/#{a}"
  end

  defp to_uniq_entries(%{kind: :module}) do
    []
  end

  defp to_uniq_entries(%{kind: :function} = fun) do
    to_entries(fun)
  end

  defp to_hint(%{kind: :module, name: name}, hint) do
    format_hint(name, hint) <> "."
  end

  defp to_hint(%{kind: :function, name: name}, hint) do
    format_hint(name, hint)
  end

  defp format_hint(name, hint) do
    hint_size = byte_size(hint)
    :binary.part(name, hint_size, byte_size(name) - hint_size)
  end
end
alchemist-20180312.1304/alchemist-server/lib/helpers/response.exs0000664000175000017500000000043714133447044023057 0ustar  kimrkimrdefmodule Alchemist.Helpers.Response do

  @moduledoc false

  def endmark(nil, cmd) do
    "END-OF-#{cmd}\n"
  end

  def endmark("", cmd) do
    "END-OF-#{cmd}\n"
  end

  def endmark(response, cmd) do
    response = String.strip(response)
    "#{response}\nEND-OF-#{cmd}\n"
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/0000775000175000017500000000000014133447044017603 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/lib/api/version.exs0000664000175000017500000000036114133447044022011 0ustar  kimrkimrCode.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Version do

  @moduledoc false
  @version "0.1.0-beta"

  alias Alchemist.Helpers.Response

  def request do
    @version |> Response.endmark("VERSION")
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/docl.exs0000664000175000017500000000343714133447044021254 0ustar  kimrkimrCode.require_file "../helpers/module_info.exs", __DIR__
Code.require_file "../helpers/capture_io.exs", __DIR__
Code.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Docl do

  @moduledoc false

  import IEx.Helpers, warn: false

  alias Alchemist.Helpers.ModuleInfo
  alias Alchemist.Helpers.CaptureIO
  alias Alchemist.Helpers.Response

  def request(args) do
    args
    |> normalize
    |> process
    |> Response.endmark("DOCL")
  end

  def process([expr, modules, aliases]) do
    search(expr, modules, aliases)
  end

  def search(nil), do: true
  def search(expr) do
    try do
      help = CaptureIO.capture_io(fn ->
        Code.eval_string("h(#{expr})", [], __ENV__)
      end)
      help
    rescue
      _e -> nil
    end
  end

  def search(expr, modules, []) do
    expr = to_string expr
    unless function?(expr) do
      search(expr)
    else
      search_with_context(modules, expr)
    end
  end

  def search(expr, modules, aliases) do
    unless function?(expr) do
      String.split(expr, ".")
      |> ModuleInfo.expand_alias(aliases)
      |> search
    else
      search_with_context(modules, expr)
    end
  end

  defp search_with_context(modules, expr) do
    modules ++ [Kernel, Kernel.SpecialForms]
    |> build_search(expr)
    |> search
  end

  defp build_search(modules, search) do
    function = Regex.replace(~r/\/[0-9]$/, search, "")
    function = String.to_atom(function)
    for module <- modules,
    ModuleInfo.docs?(module, function) do
      "#{module}.#{search}"
    end |> List.first
  end

  defp function?(expr) do
    Regex.match?(~r/^[a-z_]/, expr)
  end

  defp normalize(request) do
    {{expr, [ context: _,
              imports: imports,
              aliases: aliases]}, _} = Code.eval_string(request)
    [expr, imports, aliases]
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/defl.exs0000664000175000017500000000415014133447044021236 0ustar  kimrkimrCode.require_file "../helpers/module_info.exs", __DIR__
Code.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Defl do

  @moduledoc false

  alias Alchemist.Helpers.ModuleInfo
  alias Alchemist.Helpers.Response

  def request(args) do
    args
    |> normalize
    |> process
    |> endmark("DEFL")
  end

  defp endmark(nil , cmd) do
    "\n" <> Response.endmark(nil, cmd)
  end

  defp endmark(response , cmd) do
    Response.endmark(response, cmd)
  end


  def process([nil, function, [context: _, imports: [], aliases: _]]) do
    look_for_kernel_functions(function)
  end

  def process([nil, function, [context: _, imports: imports, aliases: _ ]]) do
    module = Enum.filter(imports, &ModuleInfo.has_function?(&1, function))
    |> List.first

    case module do
      nil -> look_for_kernel_functions(function)
      _   -> source(module)
    end
  end

  def process([module, _function, [context: _, imports: _, aliases: aliases]]) do
    if elixir_module?(module) do
      module
      |> Module.split
      |> ModuleInfo.expand_alias(aliases)
    else
      module
    end |> source
  end

  defp elixir_module?(module) do
    module == Module.concat(Elixir, module)
  end

  defp look_for_kernel_functions(function) do
    cond do
      ModuleInfo.docs?(Kernel, function) ->
        source(Kernel)
      ModuleInfo.docs?(Kernel.SpecialForms, function) ->
        source(Kernel.SpecialForms)
      true -> ""
    end
  end

  defp source([]), do: nil
  defp source(module) when is_list(module) do
    module
    |> Module.concat
    |> do_source
  end
  defp source(module), do: do_source(module)

  defp do_source(module) do
    if Code.ensure_loaded? module do
      case module.module_info(:compile)[:source] do
        nil    -> nil
        source -> List.to_string(source)
      end
    end
  end

  defp normalize(request) do
    {{expr, context_info}, _} = Code.eval_string(request)
    [module, function]        = String.split(expr, ",", parts: 2)
    {module, _}               = Code.eval_string(module)
    function                  = String.to_atom function
    [module, function, context_info]
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/ping.exs0000664000175000017500000000031714133447044021262 0ustar  kimrkimrCode.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Ping do

  @moduledoc false

  alias Alchemist.Helpers.Response

  def request do
    Response.endmark("PONG", "PING")
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/eval.exs0000664000175000017500000000300514133447044021251 0ustar  kimrkimrCode.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Eval do

  @moduledoc false

  alias Alchemist.Helpers.CaptureIO
  alias Alchemist.Helpers.Response

  def request(args) do
    args
    |> normalize
    |> process
    |> Response.endmark("EVAL")
  end

  def process({:eval, file}) do
    CaptureIO.capture_io(fn ->
      try do
        File.read!("#{file}")
        |> Code.eval_string
        |> Tuple.to_list
        |> List.first
        |> IO.inspect
      rescue
        e -> IO.inspect e
      end
    end)
  end

  def process({:quote, file}) do
    CaptureIO.capture_io(fn ->
      try do
        File.read!("#{file}")
        |> Code.string_to_quoted
        |> Tuple.to_list
        |> List.last
        |> IO.inspect
      rescue
        e -> IO.inspect e
      end
    end)
  end

  def process({:expand, file}) do
    CaptureIO.capture_io(fn ->
      try do
        {_, expr} = File.read!("#{file}")
                    |> Code.string_to_quoted
        res = Macro.expand(expr, __ENV__)
        IO.puts Macro.to_string(res)
      rescue
        e -> IO.inspect e
      end
    end)
  end

  def process({:expand_once, file}) do
    CaptureIO.capture_io(fn ->
      try do
        {_, expr} = File.read!("#{file}")
                    |> Code.string_to_quoted
        res = Macro.expand_once(expr, __ENV__)
        IO.puts Macro.to_string(res)
      rescue
        e -> IO.inspect e
      end
    end)
  end

  def normalize(request) do
    {expr , _} = Code.eval_string(request)
    expr
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/info.exs0000664000175000017500000000337514133447044021267 0ustar  kimrkimrCode.require_file "../helpers/module_info.exs", __DIR__
Code.require_file "../helpers/complete.exs", __DIR__
Code.require_file "../helpers/capture_io.exs", __DIR__
Code.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Info do

  @moduledoc false

  import IEx.Helpers, warn: false

  alias Alchemist.Helpers.ModuleInfo
  alias Alchemist.Helpers.Complete
  alias Alchemist.Helpers.CaptureIO
  alias Alchemist.Helpers.Response

  def request(args) do
    args
    |> normalize
    |> process
    |> Response.endmark("INFO")
  end

  def process(:modules) do
    modules = ModuleInfo.all_applications_modules
    |> Enum.uniq
    |> Enum.reject(&is_nil/1)
    |> Enum.filter(&ModuleInfo.moduledoc?/1)

    functions = Complete.run('')

    modules ++ functions
    |> Enum.uniq
    |> Enum.join("\n")
  end

  def process(:mixtasks) do
    # append things like hex or phoenix archives to the load_path
    Mix.Local.append_archives

    :code.get_path
    |> Mix.Task.load_tasks
    |> Enum.map(&Mix.Task.task_name/1)
    |> Enum.sort
    |> Enum.join("\n")
  end

  def process({:info, arg}) do
    try do
      CaptureIO.capture_io(fn ->
        Code.eval_string("i(#{arg})", [], __ENV__)
      end)
    rescue
      _e -> nil
    end
  end

  def process({:types, arg}) do
    try do
      CaptureIO.capture_io(fn ->
        Code.eval_string("t(#{arg})", [], __ENV__)
      end)
    rescue
      _e -> nil
    end
  end

  def process(nil) do
   nil
  end

  def normalize(request) do
    try do
      Code.eval_string(request)
    rescue
      _e -> nil
    else
      {{_, type }, _}     -> type
      {{_, type, arg}, _} ->
        if Version.match?(System.version, ">=1.2.0-rc") do
          {type, arg}
        else
          nil
        end
    end
  end
end
alchemist-20180312.1304/alchemist-server/lib/api/comp.exs0000664000175000017500000000162214133447044021263 0ustar  kimrkimrCode.require_file "../helpers/complete.exs", __DIR__
Code.require_file "../helpers/response.exs", __DIR__

defmodule Alchemist.API.Comp do

  @moduledoc false

  alias Alchemist.Helpers.Complete
  alias Alchemist.Helpers.Response

  def request(args) do
    args
    |> normalize
    |> process
  end

  def process([nil, _, imports, _]) do
    Complete.run('', imports) ++ Complete.run('')
    |> response
  end

  def process([hint, _context, imports, aliases]) do
    Application.put_env(:"alchemist.el", :aliases, aliases)

    Complete.run(hint, imports) ++ Complete.run(hint)
    |> response
  end

  defp normalize(request) do
    {{hint, [ context: context,
              imports: imports,
              aliases: aliases ]}, _} =  Code.eval_string(request)
    [hint, context, imports, aliases]
  end

  defp response(result) do
    result
    |> Enum.join("\n")
    |> Response.endmark("COMP")
  end

end
alchemist-20180312.1304/alchemist-server/lib/server/0000775000175000017500000000000014133447044020340 5ustar  kimrkimralchemist-20180312.1304/alchemist-server/lib/server/socket.exs0000664000175000017500000000307514133447044022356 0ustar  kimrkimrCode.require_file "../helpers/process_commands.exs", __DIR__

defmodule Alchemist.Server.Socket do

  alias Alchemist.Helpers.ProcessCommands

  def start(opts) do
    import Supervisor.Spec

    env = Keyword.get(opts, :env)
    port = Keyword.get(opts, :port, 0)

    children = [
      supervisor(Task.Supervisor, [[name: Alchemist.Server.Socket.TaskSupervisor]]),
      worker(Task, [__MODULE__, :accept, [env, port]])
    ]

    opts = [strategy: :one_for_one, name: Alchemist.Server.Socket.Supervisor]
    Supervisor.start_link(children, opts)
  end

  def accept(env, port) do
    {:ok, socket} = :gen_tcp.listen(port,
                    [:binary, packet: :line, active: false, reuseaddr: true])
    {:ok, port} = :inet.port(socket)
    IO.puts "ok|localhost:#{port}"
    loop_acceptor(socket, env)
  end

  defp loop_acceptor(socket, env) do
    {:ok, client} = :gen_tcp.accept(socket)
    {:ok, pid} = Task.Supervisor.start_child(Alchemist.Server.Socket.TaskSupervisor, fn -> serve(client, env) end)
    :ok = :gen_tcp.controlling_process(client, pid)
    loop_acceptor(socket, env)
  end

  defp serve(socket, env) do
    case read_line(socket) do
      :closed -> {:stop, :closed}
      data when is_binary(data) ->

        data
        |> String.strip
        |> ProcessCommands.process(env)
        |> write_line(socket)

        serve(socket, env)
    end
  end

  defp read_line(socket) do
    case :gen_tcp.recv(socket, 0) do
      {:ok, data} -> data
      {:error, :closed} -> :closed
    end
  end

  defp write_line(line, socket) do
    :gen_tcp.send(socket, line)
  end
end
alchemist-20180312.1304/alchemist-server/lib/server/io.exs0000664000175000017500000000101114133447044021461 0ustar  kimrkimrCode.require_file "../helpers/process_commands.exs", __DIR__

defmodule Alchemist.Server.IO do

  @moduledoc false

  use GenServer

  alias Alchemist.Helpers.ProcessCommands

  def start(opts) do
    env = Keyword.get(opts, :env)
    GenServer.start_link(__MODULE__,  env, [])
  end

  def init(env) do
    {:ok, env, 0}
  end

  def handle_info(:timeout, env) do
    ProcessCommands.process(read_line(), env)
    |> IO.write
    {:noreply, env, 0}
  end

  def read_line do
    IO.gets("") |> String.rstrip()
  end
end
alchemist-20180312.1304/alchemist-server/lib/server.exs0000664000175000017500000000207314133447044021063 0ustar  kimrkimrCode.require_file "server/io.exs", __DIR__
Code.require_file "server/socket.exs", __DIR__

defmodule Alchemist.Server do

  @moduledoc """
  The Alchemist-Server operates as an informant for a specific desired
  Elixir Mix project and serves with informations as the following:

    * Completion for Modules and functions.
    * Documentation lookup for Modules and functions.
    * Code evaluation and quoted representation of code.
    * Definition lookup of code.
    * Listing of all available Mix tasks.
    * Listing of all available Modules with documentation.
  """

  alias Alchemist.Server.IO, as: ServerIO
  alias Alchemist.Server.Socket, as: ServerSocket

  def start([args]) do
    {opts, _, _} = OptionParser.parse(args, switches: [port: :integer])
    env = Keyword.get(opts, :env, "dev")
    noansi = Keyword.get(opts, :no_ansi, false)
    Application.put_env(:iex, :colors, [enabled: !noansi])
    case Keyword.get(opts, :listen, false) do
      false -> ServerIO.start([env: env])
      true -> ServerSocket.start(opts)
    end
    :timer.sleep :infinity
  end
end
alchemist-20180312.1304/alchemist-project.el0000664000175000017500000002236014133447044016751 0ustar  kimrkimr;;; alchemist-project.el --- API to identify Elixir mix projects.

;; Copyright © 2014-2017 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:

;; API to identify Elixir mix projects.

;;; Code:

(require 'cl-lib)
(require 'dash)
(require 's)
(require 'alchemist-utils)
(require 'alchemist-file)

;; Tell the byte compiler about autoloaded functions from packages
(eval-when-compile
  (declare-function alchemist-goto-elixir-source-dir ""))

(defgroup alchemist-project nil
  "API to identify Elixir mix projects."
  :prefix "alchemist-help-"
  :group 'alchemist)

(defconst alchemist-project-mix-project-indicator "mix.exs"
  "File which indicates the root directory of an Elixir Mix project.")

(defconst alchemist-project-hex-pkg-indicator ".hex"
  "File which indicates the root directory of an Elixir Hex package.")

(defvar alchemist-project-root-path-cache nil
  "Variable which holds the cached project root path.")

(defun alchemist-project-elixir-p ()
  "Return non-nil if `default-directory' is inside the Elixir source codebase."
  (stringp (alchemist-project-elixir-root)))

(defun alchemist-project-elixir-root (&optional dir)
  "Return root directory of the Elixir source."
  (if (and (not (s-blank? alchemist-goto-elixir-source-dir))
	   (string-prefix-p (expand-file-name alchemist-goto-elixir-source-dir)
			    (expand-file-name default-directory)))
      alchemist-goto-elixir-source-dir
    nil))

(defun alchemist-project-p ()
  "Return non-nil if `default-directory' is inside an Elixir Mix project."
  (stringp (alchemist-project-root)))

(defun alchemist-project-top-level-dir-p (dir)
  "Return non-nil if DIR is the top level directory."
  (equal dir (file-name-directory (directory-file-name dir))))

(defun alchemist-project-root (&optional dir)
  "Return root directory of the current Elixir Mix project.

It starts walking the directory tree to find the Elixir Mix root directory
from `default-directory'. If DIR is non-nil it starts walking the
directory from there instead."
  (if (and alchemist-project-root-path-cache
	   (string-prefix-p alchemist-project-root-path-cache
			    (expand-file-name default-directory)))
      alchemist-project-root-path-cache
    (let* ((dir (file-name-as-directory (or dir (expand-file-name default-directory))))
	   (present-files (directory-files dir)))
      (cond ((alchemist-project-top-level-dir-p dir)
	     nil)
	    ((-contains-p present-files alchemist-project-hex-pkg-indicator)
	     (alchemist-project-root (file-name-directory (directory-file-name dir))))
	    ((-contains-p present-files alchemist-project-mix-project-indicator)
	     (setq alchemist-project-root-path-cache dir)
	     dir)
	    (t
	     (alchemist-project-root (file-name-directory (directory-file-name dir))))))))

(defun alchemist-project-root-or-default-dir ()
  "Return the current Elixir mix project root or `default-directory'."
  (let* ((project-root (alchemist-project-root))
         (dir (if project-root
                  project-root
                default-directory)))
    dir))

(defun alchemist-project-toggle-file-and-tests-other-window ()
  "Toggle between a file and its tests in other window."
  (interactive)
  (if (alchemist-utils-test-file-p)
      (alchemist-project-open-file-for-current-tests 'find-file-other-window)
    (alchemist-project-open-tests-for-current-file 'find-file-other-window)))

(defun alchemist-project-toggle-file-and-tests ()
  "Toggle between a file and its tests in the current window."
  (interactive)
  (if (alchemist-utils-test-file-p)
      (alchemist-project-open-file-for-current-tests 'find-file)
    (alchemist-project-open-tests-for-current-file 'find-file)))

(defun alchemist-project-file-under-test (file directory)
  "Return the file which are tested by FILE.
DIRECTORY is the place where the file under test is located."
  (let* ((filename (file-relative-name file (alchemist-project-root)))
         (filename (replace-regexp-in-string "^test" directory filename))
         (filename (replace-regexp-in-string "_test\.exs$" "\.ex" filename)))
    (concat (alchemist-project-root) filename)))

(defun alchemist-project-open-file-for-current-tests (opener)
  "Visit the implementation file for the current buffer with OPENER."
  (let* ((filename (alchemist-project-file-under-test (buffer-file-name) "web"))
         (filename (if (file-exists-p filename)
                       filename
                     (alchemist-project-file-under-test (buffer-file-name) "lib"))))
    (funcall opener filename)))

(defun alchemist-project-open-tests-for-current-file (opener)
  "Visit the test file for the current buffer with OPENER."
  (let* ((filename (file-relative-name (buffer-file-name) (alchemist-project-root)))
         (filename (replace-regexp-in-string "^lib/" "test/" filename))
         (filename (replace-regexp-in-string "^apps/\\(.*\\)/lib/" "apps/\\1/test/" filename))
         (filename (replace-regexp-in-string "^web/" "test/" filename))
         (filename (replace-regexp-in-string "^apps/\\(.*\\)/web/" "apps/\\1/test/" filename))
         (filename (replace-regexp-in-string "\.ex$" "_test\.exs" filename))
         (filename (format "%s/%s" (alchemist-project-root) filename)))
    (if (file-exists-p filename)
        (funcall opener filename)
      (if (y-or-n-p "No test file found; create one now?")
          (alchemist-project--create-test-for-current-file
           filename (current-buffer))
        (message "No test file found.")))))

(defun alchemist-project--create-test-for-current-file (filename buffer)
  "Creates and populates a test module, FILENAME, for the code in BUFFER.
The module name given to the test module is determined from the name of the
first module defined in BUFFER."
  (let* ((directory-name (file-name-directory filename))
         (module-name (alchemist-project--grok-module-name buffer))
         (test-module-name (concat module-name "Test")))
    (unless (file-exists-p directory-name)
      (make-directory (file-name-directory filename) t))
    (alchemist-project--insert-test-boilerplate
     (find-file-other-window filename) test-module-name)))

(defun alchemist-project--grok-module-name (buffer)
  "Determines the name of the first module defined in BUFFER."
  (save-excursion
    (with-current-buffer buffer
      (goto-char (point-min))
      (re-search-forward "defmodule\\s-\\(.+?\\)\\s-?,?\\s-do")
      (match-string 1))))

(defun alchemist-project--insert-test-boilerplate (buffer module)
  "Inserts ExUnit boilerplate for MODULE in BUFFER.
Point is left in a convenient location."
  (with-current-buffer buffer
    (insert (concat "defmodule " module " do\n"
                    "  use ExUnit.Case\n\n\n"
                    "end\n"))
    (goto-char (point-min))
    (beginning-of-line 4)
    (indent-according-to-mode)))

(defun alchemist-project-run-tests-for-current-file ()
  "Run the tests related to the current file."
  (interactive)
  (alchemist-project-open-tests-for-current-file 'alchemist-mix-test-file))

(defun alchemist-project-create-file ()
  "Create a file under lib/ in the current project.

The newly created buffer is filled with a module definition based on the file name."
  (interactive)
  (let ((root (alchemist-project-root)))
    (if (not root)
        (message "You're not in a Mix project")
      (let* ((lib-path (concat root "lib/"))
             (abs-path (read-file-name "New file in lib/: " lib-path))
             (abs-path (alchemist-utils-add-ext-to-path-if-not-present abs-path ".ex"))
             (relative-path (file-relative-name abs-path lib-path)))
        (if (file-readable-p abs-path)
            (message "%s already exists" relative-path)
          (make-directory (file-name-directory abs-path) t)
          (find-file abs-path)
          (insert (concat "defmodule "
                          (alchemist-utils-path-to-module-name relative-path)
                          " do\n"
                          "  \n"
                          "end\n"))
          (goto-char (point-min))
          (beginning-of-line 2)
          (back-to-indentation))))))

(defun alchemist-project-name ()
  "Return the name of the current Elixir Mix project."
  (if (alchemist-project-p)
      (car (cdr (reverse (split-string (alchemist-project-root) "/"))))
    ""))

(defun alchemist-project-find-dir (directory)
  (unless (alchemist-project-p)
    (error "Could not find an Elixir Mix project root."))
  (alchemist-file-find-files (alchemist-project-root) directory))

(defun alchemist-project-find-lib ()
  (interactive)
  (alchemist-project-find-dir "lib"))

(defun alchemist-project-find-test ()
  (interactive)
  (alchemist-project-find-dir "test"))

(provide 'alchemist-project)

;;; alchemist-project.el ends here
alchemist-20180312.1304/alchemist-macroexpand.el0000664000175000017500000001411114133447044017577 0ustar  kimrkimr;;; alchemist-macroexpand.el --- Macro expansion support -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

;; Macro expansion support

;;; Code:

(require 'alchemist-server)
(require 'alchemist-interact)

(defgroup alchemist-macroexpand nil
  "Macro expansion support."
  :prefix "alchemist-macroexpand-"
  :group 'alchemist)

(defvar alchemist-macroexpand-filter-output nil)

(defconst alchemist-macroexpand-buffer-name "*alchemist macroexpand*"
  "Name of the Elixir Macro expand buffer.")

(defun alchemist-macroexpand-filter (_process output)
  (setq alchemist-macroexpand-filter-output (cons output alchemist-macroexpand-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-create-popup alchemist-macroexpand-buffer-name
                                     (alchemist-server-prepare-filter-output alchemist-macroexpand-filter-output)
                                     #'(lambda ()
                                         (elixir-mode)
                                         (alchemist-macroexpand-mode)))
    (setq alchemist-macroexpand-filter-output nil)))

(defun alchemist-macroexpand-insert-filter (_process output)
  (setq alchemist-macroexpand-filter-output (cons output alchemist-macroexpand-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-insert-as-comment
     (alchemist-server-prepare-filter-output alchemist-macroexpand-filter-output))
    (setq alchemist-macroexpand-filter-output nil)))

(defun alchemist-macroexpand-expand-request (expr)
  (let ((file (make-temp-file "alchemist-expand" nil ".exs")))
    (with-temp-file file
      (insert expr))
    (alchemist-server-eval (format "{ :expand, '%s' }" file) #'alchemist-macroexpand-filter)))

(defun alchemist-macroexpand-expand-and-print-request (expr)
  (let ((file (make-temp-file "alchemist-expand" nil ".exs")))
    (with-temp-file file
      (insert expr))
    (alchemist-server-eval (format "{ :expand, '%s' }" file) #'alchemist-macroexpand-insert-filter)))

(defun alchemist-macroexpand-expand-once-request (expr)
  (let ((file (make-temp-file "alchemist-expand-once" nil ".exs")))
    (with-temp-file file
      (insert expr))
    (alchemist-server-eval (format "{ :expand_once, '%s' }" file) #'alchemist-macroexpand-filter)))

(defun alchemist-macroexpand-expand-once-and-print-request (expr)
  (let ((file (make-temp-file "alchemist-expand-once" nil ".exs")))
    (with-temp-file file
      (insert expr))
    (alchemist-server-eval (format "{ :expand_once, '%s' }" file) #'alchemist-macroexpand-insert-filter)))

(defun alchemist-macroexpand-current-line ()
  "Macro expand the Elixir code on the current line."
  (interactive)
  (alchemist-macroexpand-expand-request (thing-at-point 'line)))

(defun alchemist-macroexpand-print-current-line ()
  "Macro expand the Elixir code on the current line and insert the result."
  (interactive)
  (alchemist-macroexpand-expand-and-print-request (thing-at-point 'line)))

(defun alchemist-macroexpand-once-current-line ()
  "Macro expand the Elixir code on the current line."
  (interactive)
  (alchemist-macroexpand-expand-once-request (thing-at-point 'line)))

(defun alchemist-macroexpand-once-print-current-line ()
  "Macro expand the Elixir code on the current line and insert the result."
  (interactive)
  (alchemist-macroexpand-expand-once-and-print-request (thing-at-point 'line)))

(defun alchemist-macroexpand-print-region (beg end)
  "Macro expand the Elixir code on marked region and insert the result."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (when (> end beg)
      (exchange-point-and-mark))
    (alchemist-macroexpand-expand-and-print-request string)))

(defun alchemist-macroexpand-region (beg end)
  "Macro expand the Elixir code on marked region."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (alchemist-macroexpand-expand-request string)))

(defun alchemist-macroexpand-once-print-region (beg end)
  "Macro expand the Elixir code on marked region once and insert the result."
  (interactive "r")
  (let ((string (buffer-substring-no-properties beg end)))
    (when (> end beg)
      (exchange-point-and-mark))
    (alchemist-macroexpand-expand-once-and-print-request string)))

(defun alchemist-macroexpand-once-region (beg end)
  "Macro expand the Elixir code on marked region once."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (alchemist-macroexpand-expand-once-request string)))

(defun alchemist-macroexpand-close-popup ()
  "Quit the macroexpand buffer window."
  (interactive)
  (quit-windows-on alchemist-macroexpand-buffer-name))

(defvar alchemist-macroexpand-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "q") #'quit-window)
    map)
  "Keymap for `alchemist-macroexpand-mode'.")

(define-minor-mode alchemist-macroexpand-mode
  "Minor mode for Alchemist Elixir macroexpand functionality.

\\{alchemist-macroexpand-mode-map}"
  nil
  alchemist-macroexpand-mode-map)

(provide 'alchemist-macroexpand)

;;; alchemist-macroexpand.el ends here
alchemist-20180312.1304/alchemist-interact.el0000664000175000017500000000404314133447044017112 0ustar  kimrkimr;;; alchemist-interact.el --- Interaction interface -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

;; Interaction interface.

;;; Code:

(defgroup alchemist-interact nil
  "Interaction interface."
  :prefix "alchemist-interact-"
  :group 'alchemist)

(defun alchemist-interact-insert-as-comment (string)
  "Insert STRING at point as comment."
  (let ((lines (split-string string "\n")))
    (if (> (length lines) 1)
        (save-excursion
          (end-of-line)
          (mapc (lambda (s)
                  (newline)
                  (insert (format "# => %s" s))
                  (indent-according-to-mode))
                lines))
      (save-excursion
        (end-of-line)
        (insert (format "  # => %s" string))))))

(defun alchemist-interact-create-popup (name content mode)
  "Create a NAME buffer and insert CONTENT.
Call the MODE afterwards."
  (let ((buffer (get-buffer-create name)))
    (with-current-buffer buffer
      (with-current-buffer-window
       buffer (cons 'display-buffer-below-selected
                    '((window-height . fit-window-to-buffer)))
       (lambda (_window _buffer))
       (let ((inhibit-read-only t))
         (insert content)
         (goto-char (point-min))
         (funcall mode))))))

(provide 'alchemist-interact)

;;; alchemist-interact.el ends here
alchemist-20180312.1304/alchemist-compile.el0000664000175000017500000000547114133447044016737 0ustar  kimrkimr;;; alchemist-compile.el --- Elixir compilation functionality

;; Copyright © 2014-2017 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:

;; Elixir compilation functionality.

;;; Code:

(require 'alchemist-utils)
(require 'alchemist-report)

(defgroup alchemist-compile nil
  "Elixir compilation functionality."
  :prefix "alchemist-compile-"
  :group 'alchemist)

;; Variables

(defcustom alchemist-compile-command "elixirc"
  "The shell command for elixirc."
  :type 'string
  :group 'alchemist-compile)

(defvar alchemist-compile-buffer-name "*alchemist elixirc*"
  "Name of the elixir output buffer.")

(defvar alchemist-compile-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "q" #'quit-window)
    map))

;; Private functions

(defun alchemist-compile--file (filename)
  (cond ((not (file-exists-p filename)) (error "The given file doesn't exist"))
        ((string-match "\.exs$" filename) (error "The given file is an Elixir Script"))
        (t (alchemist-compile (list alchemist-compile-command (expand-file-name filename))))))

(defun alchemist-compile--read-command (command)
  (read-shell-command "elixirc command: " (concat command " ")))

;; Public functions

(defun alchemist-compile-this-buffer ()
  "Compile the current buffer with elixirc."
  (interactive)
  (alchemist-compile--file buffer-file-name))

(defun alchemist-compile-file (filename)
  "Compile the given FILENAME."
  (interactive "Felixirc: ")
  (alchemist-compile--file (expand-file-name filename)))

(define-derived-mode alchemist-compile-mode fundamental-mode "Elixir Compile Mode"
  "Major mode for compiling Elixir files.

\\{alchemist-compile-mode-map}"
  (setq buffer-read-only t)
  (setq-local truncate-lines t)
  (setq-local electric-indent-chars nil))

(defun alchemist-compile (cmdlist)
  "Compile CMDLIST with elixirc."
  (interactive (list (alchemist-compile--read-command alchemist-compile-command)))
  (let ((command (alchemist-utils-build-command cmdlist)))
    (alchemist-report-run command "alchemist-compile-report" alchemist-compile-buffer-name 'alchemist-compile-mode)))

(provide 'alchemist-compile)

;;; alchemist-compile.el ends here
alchemist-20180312.1304/alchemist-hooks.el0000664000175000017500000000460714133447044016432 0ustar  kimrkimr;;; alchemist-hooks.el --- Hooks functionality

;; Copyright © 2014-2017 Samuel Tonini

;; Author: Samuel Tonini <tonini.samuel@gmail.com
;;         Dave Thomas <http://pragdave.me>

;; 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:

;; Hooks functionality

;;; Code:

(require 'alchemist-project)
(require 'alchemist-mix)
(require 'alchemist-report)
(require 'alchemist-test-mode)

(defgroup alchemist-hooks nil
  "Hooks"
  :prefix "alchemist-hooks-"
  :group 'alchemist)

(defcustom alchemist-hooks-test-on-save nil
  "If t, run `alchemist-mix-test' on save."
  :type 'boolean
  :group 'alchemist-hooks)

(defcustom alchemist-hooks-compile-on-save nil
  "If t, run `alchemist-mix-compile' on save."
  :type 'boolean
  :group 'alchemist-hooks)

(defun alchemist-hooks-test-on-save ()
  (when (and alchemist-hooks-test-on-save
             (alchemist-project-p))
    (alchemist-report-run "mix test"
                          alchemist-test-report-process-name
                          alchemist-test-report-buffer-name
                          #'alchemist-test-report-mode
                          #'alchemist-test--handle-exit
                          t)))

(defun alchemist-hooks-compile-on-save ()
  (when (and alchemist-hooks-compile-on-save
             (alchemist-project-p))
    (alchemist-report-run "mix compile"
                          alchemist-mix-process-name
                          alchemist-mix-buffer-name
                          #'alchemist-mix-mode
                          nil
                          t)))

(eval-after-load 'elixir-mode
  '(progn
     (add-hook 'after-save-hook 'alchemist-hooks-test-on-save nil nil)
     (add-hook 'after-save-hook 'alchemist-hooks-compile-on-save nil nil)))

(provide 'alchemist-hooks)

;;; alchemist-hooks.el ends here
alchemist-20180312.1304/alchemist-key.el0000664000175000017500000000236714133447044016100 0ustar  kimrkimr;;; alchemist-key.el --- Key prefix setup for Alchemist related key commands

;; Copyright © 2014-2017 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:

;; Key prefix setup for Alchemist related key commands.

;;; Code:

(defgroup alchemist-key nil
  "Key prefix setup for Alchemist related key commands."
  :prefix "alchemist-key-"
  :group 'alchemist)

(defcustom alchemist-key-command-prefix (kbd "C-c a")
  "The prefix for Alchemist related key commands."
  :type 'string
  :group 'alchemist)

(provide 'alchemist-key)

;;; alchemist-key.el ends here
alchemist-20180312.1304/alchemist-report.el0000664000175000017500000001565714133447044016631 0ustar  kimrkimr;;; alchemist-report.el --- Run command in a process and handles buffer of it

;; Copyright © 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:

;; Run command in a process and handles buffer output and display

;;; Code:

(require 'ansi-color)
(require 'alchemist-project)

(defgroup alchemist-report nil
  "Run command in a process and handles buffer output and display"
  :prefix "alchemist-report-"
  :group 'alchemist)

(defvar alchemist-report-on-exit nil)
(defvar alchemist-report-on-exit-function nil)
(defvar alchemist-report-on-render nil)
(defvar alchemist-report-on-render-function nil)
(defvar alchemist-report--last-run-status nil)
(defvar alchemist-report-mode-name nil)

(defun alchemist-report--kill-process (process)
  "Interrupt and kill the running report PROCESS."
  (when process
    (with-current-buffer (process-buffer process)
      (let* ((mode-name (if (stringp mode-name)
                  (replace-regexp-in-string ":.+$" "" mode-name)
                mode-name)))
        (if (or (not (eq (process-status process) 'run))
                (eq (process-query-on-exit-flag process) nil)
                (yes-or-no-p
                 (format "A %s process already running; kill it? "
                         mode-name)))
            (condition-case ()
                (progn
                  (interrupt-process process)
                  (sit-for 1)
                  (delete-process process))
              (error nil))
          (error "Cannot have two processes in `%s' at once"
                 (buffer-name)))))))

(defun alchemist-report--sentinel (process status)
  "Sentinel for test report buffer."
  (if (memq (process-status process) '(exit signal))
      (let ((buffer (process-buffer process)))
        (if (null (buffer-name buffer))
            (set-process-buffer process nil)
          (progn
            (alchemist-report--render-report buffer)
            (alchemist-report--handle-exit status buffer)
            (alchemist-report-update-mode-name process)
            (delete-process process))))))

(defun alchemist-report--render-report (buffer)
  "Call the defined render functions for the BUFFER."
  (when alchemist-report-on-render-function
    (funcall alchemist-report-on-render-function buffer)))

(defun alchemist-report--handle-exit (status buffer)
  "Call the defined exit function specified in `alchemist-report-on-exit-function'.
Argument for the exit function is the STATUS and BUFFER of the finished process."
  (alchemist-report--store-process-status status)
  (when alchemist-report-on-exit-function
    (funcall alchemist-report-on-exit-function status buffer)))

(defun alchemist-report--store-process-status (status)
  "Store STATUS of the last finished process."
  (setq alchemist-report--last-run-status status))

(defun alchemist-report--last-run-successful-p ()
  "Return non-nil if the last process successfully finished."
  (when (string-prefix-p "finished" alchemist-report--last-run-status) t))

(defun alchemist-report-filter (process output)
  "Process filter for report buffers."
  (with-current-buffer (process-buffer process)
    (let* ((buffer-read-only nil)
           (output (if (string= (process-name process) alchemist-test-report-process-name)
                       (alchemist-test-clean-compilation-output output)
                     output))
           (moving (= (point) (process-mark process))))
      (save-excursion
        (goto-char (process-mark process))
        (insert output)
        (set-marker (process-mark process) (point))
        (ansi-color-apply-on-region (point-min) (point-max)))
      (if moving (goto-char (process-mark process))))))

(defun alchemist-report-update-mode-name (process)
  "Update the `mode-name' with the status of PROCESS."
  (with-current-buffer (process-buffer process)
    (when (stringp mode-name)
      (setq-local mode-name (format "%s:%s"
                                    (replace-regexp-in-string ":.+$" "" mode-name)
                                    (process-status process))))))

(defun alchemist-report-interrupt-current-process ()
  "Interrupt the current running report process."
  (interactive)
  (let ((buffer (current-buffer))
        (name (if (stringp mode-name)
                  (replace-regexp-in-string ":.+" "" mode-name)
                mode-name)))
    (if (get-buffer-process buffer)
        (interrupt-process (get-buffer-process buffer))
      (error "The [%s] process is not running" name))))

(defun alchemist-report-cleanup-process-buffer (buffer)
  "Clean the content BUFFER of process.
If there is already a running process, ask for interrupting it."
  (with-current-buffer buffer
    (let ((inhibit-read-only t)
          (process (get-buffer-process buffer)))
      (erase-buffer))))

(defun alchemist-report-display-buffer (buffer)
  "Display the BUFFER."
  (display-buffer buffer))

(defun alchemist-report-activate-mode (mode buffer)
  "Enable MODE inside BUFFER."
  (with-current-buffer buffer
    (funcall mode)
    (setq-local truncate-lines alchemist-test-truncate-lines)
    (setq-local window-point-insertion-type t)))

(defun alchemist-report-run (command process-name buffer-name mode &optional on-exit hidden)
  "Run COMMAND in a new process called PROCESS-NAME.
The output of PROCESS-NAME will be displayed in BUFFER-NAME.
After displaying BUFFER-NAME, the MODE function will be called within.

Optional ON-EXIT and HIDDEN functions could be defined.
The function ON-EXIT will be called when PROCESS-NAME is finished.
The HIDDEN variable defines if PROCESS-NAME should run in the background."
  (let* ((buffer (get-buffer-create buffer-name))
         (default-directory (alchemist-project-root-or-default-dir)))
    (alchemist-report-cleanup-process-buffer buffer)
    (alchemist-report--kill-process (get-buffer-process buffer))
    (start-process-shell-command process-name buffer command)
    (when on-exit
      (setq alchemist-report-on-exit-function on-exit))
    (set-process-sentinel (get-buffer-process buffer) 'alchemist-report--sentinel)
    (set-process-filter (get-buffer-process buffer) 'alchemist-report-filter)
    (alchemist-report-activate-mode mode buffer)
    (if (not hidden)
        (alchemist-report-display-buffer buffer))
    (alchemist-report-update-mode-name (get-buffer-process buffer))))

(provide 'alchemist-report)

;;; alchemist-report.el ends here
alchemist-20180312.1304/alchemist-execute.el0000664000175000017500000000552014133447044016744 0ustar  kimrkimr;;; alchemist-execute.el --- Elixir's script execution integration

;; Copyright © 2014-2017 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:

;; Elixir's script execution integration

;;; Code:

(require 'alchemist-utils)
(require 'alchemist-test-mode)
(require 'alchemist-report)

(defgroup alchemist-execute nil
  "Elixir's script execution integration."
  :prefix "alchemist-execute-"
  :group 'alchemist)

;; Variables

(defcustom alchemist-execute-command "elixir"
  "The shell command for elixir."
  :type 'string
  :group 'alchemist-execute)

(defvar alchemist-execute-buffer-name "*alchemist elixir*"
  "Name of the elixir output buffer.")

(defvar alchemist-execute-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "q" #'quit-window)
    map))

;; Private functions

(defun alchemist-execute--file (filename)
  (when (not (file-exists-p filename))
    (error "The given file doesn't exist"))
  (alchemist-execute (list alchemist-execute-command (expand-file-name filename))))

(defun alchemist-execute--read-command (command)
  (read-shell-command "elixir command: " (concat command " ")))

;; Public functions

(defun alchemist-execute-this-buffer ()
  "Run the current buffer through elixir."
  (interactive)
  (alchemist-execute--file buffer-file-name))

(defun alchemist-execute-file (filename)
  "Run elixir with the given FILENAME."
  (interactive "Felixir: ")
  (alchemist-execute--file (expand-file-name filename)))

(define-derived-mode alchemist-execute-mode fundamental-mode "Elixir Execute Mode"
  "Major mode for execute Elixir files.

\\{alchemist-execute-mode-map}"
  (setq buffer-read-only t)
  (setq-local truncate-lines t)
  (setq-local electric-indent-chars nil))

(defun alchemist-execute (cmdlist)
  "Run a elixir with CMDLIST."
  (interactive (list (alchemist-execute--read-command alchemist-execute-command)))
  (let ((command (alchemist-utils-build-command cmdlist)))
    (alchemist-report-run command
                          "alchemist-execute-report"
                          alchemist-execute-buffer-name
                          'alchemist-execute-mode)))

(provide 'alchemist-execute)

;;; alchemist-execute.el ends here
alchemist-20180312.1304/alchemist-eval.el0000664000175000017500000002061414133447044016232 0ustar  kimrkimr;;; alchemist-eval.el --- Elixir code inline evaluation functionality

;; Copyright © 2014-2017 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:

;; Elixir code inline evaluation functionality

;;; Code:

(require 'elixir-mode)
(require 'alchemist-server)
(require 'alchemist-interact)

(defgroup alchemist-eval nil
  "Elixir code inline evaluation functionality."
  :prefix "alchemist-eval-"
  :group 'alchemist)

(defconst alchemist-eval-buffer-name "*alchemist-eval-mode*"
  "Name of the Elixir evaluation buffer.")

(defvar alchemist-eval-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "q") #'quit-window)
    map)
  "Keymap for `alchemist-eval-mode'.")

(defvar alchemist-eval-filter-output nil)

;; Private functions

(defun alchemist-eval--insert (string)
  (let ((lines (split-string string "\n")))
    (if (> (length lines) 1)
        (progn
          (save-excursion
            (end-of-line)
            (mapc (lambda (s)
                    (newline)
                    (insert (format "# => %s" s))
                    (indent-according-to-mode))
                  lines)))
      (save-excursion
        (end-of-line)
        (insert (format "  # => %s" string))))))

(defun alchemist-eval--expression (expression)
  (let ((file (make-temp-file "alchemist-eval" nil ".exs")))
    (with-temp-file file
      (insert expression))
    (alchemist-server-eval (format "{ :eval, '%s' }" file) #'alchemist-eval-filter)))

(defun alchemist-eval--expression-and-print (expression)
  (let ((file (make-temp-file "alchemist-eval" nil ".exs")))
    (with-temp-file file
      (insert expression))
    (alchemist-server-eval (format "{ :eval, '%s' }" file) #'alchemist-eval-insert-filter)))

(defun alchemist-eval--quote-expression (expression)
  (let ((file (make-temp-file "alchemist-eval" nil ".exs")))
    (with-temp-file file
      (insert expression))
    (alchemist-server-eval (format "{ :quote, '%s' }" file) #'alchemist-eval-quoted-filter)))

(defun alchemist-eval--quote-expression-and-print (expression)
  (let ((file (make-temp-file "alchemist-eval" nil ".exs")))
    (with-temp-file file
      (insert expression))
    (alchemist-server-eval (format "{ :quote, '%s' }" file) #'alchemist-eval-quoted-insert-filter)))

(defun alchemist-eval-filter (_process output)
  (setq alchemist-eval-filter-output (cons output alchemist-eval-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-create-popup alchemist-eval-buffer-name
                                     (alchemist-server-prepare-filter-output alchemist-eval-filter-output)
                                     #'(lambda ()
                                         (elixir-mode)
                                         (alchemist-eval-mode)
                                         (ansi-color-apply-on-region (point-min) (point-max))))
    (setq alchemist-eval-filter-output nil)))

(defun alchemist-eval-insert-filter (_process output)
  (setq alchemist-eval-filter-output (cons output alchemist-eval-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-insert-as-comment
     (alchemist-server-prepare-filter-output alchemist-eval-filter-output))
    (setq alchemist-eval-filter-output nil)))

(defun alchemist-eval-quoted-filter (_process output)
  (setq alchemist-eval-filter-output (cons output alchemist-eval-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-create-popup alchemist-eval-buffer-name
                                     (alchemist-server-prepare-filter-output alchemist-eval-filter-output)
                                     #'alchemist-eval-mode)
    (setq alchemist-eval-filter-output nil)))

(defun alchemist-eval-quoted-insert-filter (_process output)
  (setq alchemist-eval-filter-output (cons output alchemist-eval-filter-output))
  (when (alchemist-server-contains-end-marker-p output)
    (alchemist-interact-insert-as-comment
     (alchemist-server-prepare-filter-output alchemist-eval-filter-output))
    (setq alchemist-eval-filter-output nil)))

;; Public functions

(defun alchemist-eval-current-line ()
  "Evaluate the Elixir code on the current line."
  (interactive)
  (alchemist-eval--expression (thing-at-point 'line)))

(defun alchemist-eval-print-current-line ()
  "Evaluate the Elixir code on the current line and insert the result."
  (interactive)
  (alchemist-eval--expression-and-print (thing-at-point 'line)))

(defun alchemist-eval-region (beg end)
  "Evaluate the Elixir code on marked region."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (alchemist-eval--expression string)))

(defun alchemist-eval-print-region (beg end)
  "Evaluate the Elixir code on marked region and insert the result."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (when (> end beg)
      (exchange-point-and-mark))
    (alchemist-eval--expression-and-print string)))

(defun alchemist-eval-buffer ()
  "Evaluate the Elixir code in the current buffer."
  (interactive)
  (let ((string (buffer-substring-no-properties (point-min) (point-max))))
    (alchemist-eval--expression string)))

(defun alchemist-eval-print-buffer ()
  "Evaluate the Elixir code in the current buffer and insert the result."
  (interactive)
  (let ((string (buffer-substring-no-properties (point-min) (point-max))))
    (goto-char (point-max))
    (alchemist-eval--expression-and-print string)))

(defun alchemist-eval-quoted-current-line ()
  "Get the Elixir code representation of the expression on the current line."
  (interactive)
  (alchemist-eval--quote-expression (thing-at-point 'line)))

(defun alchemist-eval-print-quoted-current-line ()
  "Get the Elixir code representation of the expression on the current line and insert the result."
  (interactive)
  (alchemist-eval--quote-expression-and-print (thing-at-point 'line)))

(defun alchemist-eval-quoted-region (beg end)
  "Get the Elixir code representation of the expression on marked region."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (alchemist-eval--quote-expression string)))

(defun alchemist-eval-print-quoted-region (beg end)
  "Get the Elixir code representation of the expression on marked region and insert the result."
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (let ((string (buffer-substring-no-properties beg end)))
    (when (> end beg)
      (exchange-point-and-mark))
    (alchemist-eval--quote-expression-and-print string)))

(defun alchemist-eval-quoted-buffer ()
  "Get the Elixir code representation of the expression in the current buffer."
  (interactive)
  (let ((string (buffer-substring-no-properties (point-min) (point-max))))
    (alchemist-eval--quote-expression string)))
(defun alchemist-eval-print-quoted-buffer ()
  "Get the Elixir code representation of the expression in the current buffer and insert result."
  (interactive)
  (let ((string (buffer-substring-no-properties (point-min) (point-max))))
    (alchemist-eval--quote-expression-and-print string)))

(defun alchemist-eval-close-popup ()
  "Quit the evaluation buffer window."
  (interactive)
  (quit-windows-on alchemist-eval-buffer-name))

(define-minor-mode alchemist-eval-mode
  "Minor mode for Alchemist Elixir code evaluation.

\\{alchemist-eval-mode-map}"
  nil
  " Alchemist-Eval"
  alchemist-eval-mode-map)

(provide 'alchemist-eval)

;;; alchemist-eval.el ends here
alchemist-20180312.1304/alchemist-message.el0000664000175000017500000000351114133447044016724 0ustar  kimrkimr;;; alchemist-message.el --- Internal message functionality

;; Copyright © 2014-2017 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:

;; Internal message functionality.

;;; Code:

(defgroup alchemist-message nil
  "Internal message functionality."
  :prefix "alchemist-message-"
  :group 'alchemist)

;; Variables

(defvar alchemist-message--buffer-name "*alchemist message*")

(defun alchemist-message (message)
  (alchemist-message--initialize-buffer message))

(defun alchemist-message--initialize-buffer (message)
  (display-buffer (get-buffer-create alchemist-message--buffer-name))
  (with-current-buffer alchemist-message--buffer-name
    (let ((inhibit-read-only t)
          (buffer-undo-list t))
      (erase-buffer)
      (insert message)
      (goto-char (point-min))
      (ansi-color-apply-on-region (point-min) (point-max))
      (read-only-mode)
      (alchemist-message-mode 1))))

(define-minor-mode alchemist-message-mode
  "Minor mode for displaying alchemist messages"
  :group 'alchemist-message
  :lighter " alchemist-msg"
  :keymap '(("q" . quit-window)))

(provide 'alchemist-message)

;;; alchemist-message.el ends here
alchemist-20180312.1304/alchemist-phoenix.el0000664000175000017500000001163614133447044016761 0ustar  kimrkimr;;; alchemist-phoenix.el --- Minor mode for the Phoenix web framework

;; Copyright © 2014-2017 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:

;; Minor mode for the Phoenix web framework

;;; Code:

(require 'alchemist-key)
(require 'alchemist-project)

(defgroup alchemist-phoenix nil
  "Minor mode for the Phoenix web framework."
  :prefix "alchemist-phoenix-"
  :group 'alchemist)

;;;###autoload
(defun alchemist-phoenix-project-p ()
  "Return non-nil if `default-directory' is inside a Phoenix project."
  (and (alchemist-project-p)
       (file-directory-p (concat (alchemist-project-root) "web"))))

(defun alchemist-phoenix-find-dir (directory)
  (unless (alchemist-phoenix-project-p)
    (error "Could not find a Phoenix Mix project root."))
  (alchemist-file-find-files (alchemist-project-root) directory))

(defun alchemist-phoenix-find-web ()
  (interactive)
  (alchemist-phoenix-find-dir "web"))

(defun alchemist-phoenix-find-views ()
  (interactive)
  (alchemist-phoenix-find-dir "web/views"))

(defun alchemist-phoenix-find-controllers ()
  (interactive)
  (alchemist-phoenix-find-dir "web/controllers"))

(defun alchemist-phoenix-find-channels ()
  (interactive)
  (alchemist-phoenix-find-dir "web/channels"))

(defun alchemist-phoenix-find-templates ()
  (interactive)
  (alchemist-phoenix-find-dir "web/templates"))

(defun alchemist-phoenix-find-models ()
  (interactive)
  (alchemist-phoenix-find-dir "web/models"))

(defun alchemist-phoenix-find-static ()
  (interactive)
  (alchemist-phoenix-find-dir "web/static"))

(defun alchemist-phoenix-routes (&optional prefix)
  (interactive)
  "Run the Mix task 'phoenix.routes' and list all available Phoenix routes."
  (alchemist-mix-execute '("phoenix.routes") prefix))

(defun alchemist-phoenix-router ()
  "Open the 'router.ex' file from 'web' directory."
  (interactive)
  (unless (alchemist-phoenix-project-p)
    (error "Could not find an Phoenix Mix project root."))
  (find-file (concat (alchemist-project-root) "web/router.ex")))

(defvar alchemist-phoenix-command-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "n w") #'alchemist-phoenix-find-web)
    (define-key map (kbd "n v") #'alchemist-phoenix-find-views)
    (define-key map (kbd "n c") #'alchemist-phoenix-find-controllers)
    (define-key map (kbd "n l") #'alchemist-phoenix-find-channels)
    (define-key map (kbd "n t") #'alchemist-phoenix-find-templates)
    (define-key map (kbd "n m") #'alchemist-phoenix-find-models)
    (define-key map (kbd "n s") #'alchemist-phoenix-find-static)
    (define-key map (kbd "n r") #'alchemist-phoenix-router)
    (define-key map (kbd "n R") #'alchemist-phoenix-routes)
    map)
  "Keymap for Alchemist Phoenix commands after `alchemist-key-command-prefix'.")
(fset 'alchemist-phoenix-command-map alchemist-phoenix-command-map)

(defvar alchemist-phoenix-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map alchemist-key-command-prefix 'alchemist-phoenix-command-map)
    map)
  "Keymap for Alchemist Phoenix minor mode.")

(easy-menu-define alchemist-mode-menu alchemist-phoenix-mode-map
  "Menu for Alchemist-Phoenix mode."
  '("Phoenix"
    ("Directory lookup"
     ["Lookup 'web' " alchemist-phoenix-find-web]
     ["Lookup 'web/views' " alchemist-phoenix-find-views]
     ["Lookup 'web/controllers' " alchemist-phoenix-find-controllers]
     ["Lookup 'web/channels' " alchemist-phoenix-find-channels]
     ["Lookup 'web/templates' " alchemist-phoenix-find-templates]
     ["Lookup 'web/models' " alchemist-phoenix-find-models]
     ["Lookup 'web/static'" alchemist-phoenix-find-static])
    ("Mix tasks"
     ["Run 'phoenix.routes'" alchemist-phoenix-routes])
    ["Open the 'router.ex' file" alchemist-phoenix-router]))

;;;###autoload
(define-minor-mode alchemist-phoenix-mode
  "Minor mode for Elixir Phoenix web framework projects.

The following commands are available:

\\{alchemist-phoenix-mode-map}"
  :lighter " alchemist-phoenix"
  :keymap alchemist-phoenix-mode-map
  :group 'alchemist)

;;;###autoload
(defun alchemist-phoenix-enable-mode ()
  (when (alchemist-phoenix-project-p)
    (alchemist-phoenix-mode)))

;;;###autoload
(dolist (hook '(alchemist-mode-hook))
  (add-hook hook 'alchemist-phoenix-enable-mode))

(provide 'alchemist-phoenix)

;;; alchemist-phoenix.el ends here
alchemist-20180312.1304/alchemist-company.el0000664000175000017500000001403414133447044016750 0ustar  kimrkimr;;; alchemist-company.el --- Elixir company-mode backend -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

;; Elixir company-mode backend.

;;; Code:

(require 'cl-lib)
(require 'company)
(require 'alchemist-help)
(require 'alchemist-goto)
(require 'alchemist-scope)
(require 'alchemist-server)
(require 'alchemist-complete)

(defgroup alchemist-company nil
  "Elixir company-mode backend."
  :prefix "alchemist-company-"
  :group 'alchemist)

;; Variables

(defcustom alchemist-company-show-annotation t
  "Show an annotation inline with the candidate."
  :type 'boolean
  :group 'alchemist-company)

(defvar alchemist-company-callback nil)
(defvar alchemist-company-doc-callback nil)
(defvar alchemist-company-filter-output nil)
(defvar alchemist-company-last-completion nil)

(defun alchemist-company-show-documentation (candidate)
  (interactive)
  (let* ((annotation (alchemist-company--annotation candidate))
         (candidate (if annotation
                        (format "%s%s" candidate annotation)
                      candidate))
         (candidate (alchemist-help--prepare-search-expr candidate)))
    (alchemist-server-help (alchemist-help--server-arguments candidate) #'alchemist-company-doc-buffer-filter)))

(defun alchemist-company-open-definition (candidate)
  (interactive)
  (alchemist-goto--open-definition candidate))

(defun alchemist-company--annotation (candidate)
  (get-text-property 0 'meta candidate))

(defun alchemist-company-build-scope-arg (arg)
  "Build informations about the current context."
  (let* ((modules (alchemist-utils-prepare-modules-for-elixir
                   (alchemist-scope-all-modules)))
         (aliases (alchemist-utils-prepare-aliases-for-elixir
                   (alchemist-scope-aliases))))
    (format "{ \"%s\", [ context: Elixir, imports: %s, aliases: %s ] }" arg modules aliases)))

(defun alchemist-company-build-server-arg (arg)
  (if (not (equal major-mode 'alchemist-iex-mode))
      (alchemist-company-build-scope-arg arg)
    (format "{ \"%s\", [ context: [], imports: [], aliases: [] ] }" arg)))

(defun alchemist-company-filter (_process output)
  (setq alchemist-company-filter-output (cons output alchemist-company-filter-output))
  (if (alchemist-server-contains-end-marker-p output)
      (let* ((candidates (alchemist-complete--build-candidates-from-process-output alchemist-company-filter-output)))
        (setq alchemist-company-filter-output nil)
        (alchemist-company-serve-candidates-to-callback (-distinct candidates)))))

(defun alchemist-company-doc-buffer-filter (_process output)
  (setq alchemist-company-filter-output (cons output alchemist-company-filter-output))
  (if (alchemist-server-contains-end-marker-p output)
      (let ((string (alchemist-server-prepare-filter-output alchemist-company-filter-output)))
        (setq alchemist-company-filter-output nil)
        (if (get-buffer alchemist-help-buffer-name)
            (kill-buffer alchemist-help-buffer-name))
        (with-current-buffer (get-buffer-create alchemist-help-buffer-name)
          (insert string)
          (ansi-color-apply-on-region (point-min) (point-max))
          (alchemist-help-minor-mode 1))
	(funcall alchemist-company-doc-callback (get-buffer alchemist-help-buffer-name)))))

(defun alchemist-company-serve-candidates-to-callback (candidates)
  (let* ((candidates (if candidates
                        candidates
                      (alchemist-complete--dabbrev-code-candidates)))
         (candidates (-distinct candidates)))
    (funcall alchemist-company-callback candidates)))

(defun alchemist-company-get-prefix ()
  (if (or (looking-at "\s") (eolp))
      (unless (looking-back ".+:" nil)
        (alchemist-scope-expression))))

(defun alchemist-company (command &optional arg &rest ignored)
  "`company-mode' completion back-end for Elixir."
  (interactive (list 'interactive))
  (when alchemist-company-show-annotation
    (set 'company-tooltip-align-annotations t))
  (cl-case command
    (interactive (company-begin-backend 'alchemist-company))
    (init (or (eq major-mode 'elixir-mode)
              (string= mode-name "Alchemist-IEx")))
    (prefix (and (or (eq major-mode 'elixir-mode)
                     (string= mode-name "Alchemist-IEx"))
                 (alchemist-company-get-prefix)))
    (doc-buffer (cons :async
		      (lambda (cb)
			(setq alchemist-company-doc-callback cb)
			(alchemist-company-show-documentation arg))))
    (location (alchemist-company-open-definition arg))
    (candidates (cons :async
                      (lambda (cb)
                        (setq alchemist-company-last-completion arg)
                        (setq alchemist-company-callback cb)
                        (alchemist-server-complete-candidates (alchemist-company-build-server-arg arg)
                                                              #'alchemist-company-filter))))
    (annotation (when alchemist-company-show-annotation
                  (alchemist-company--annotation arg)))))

(add-hook 'alchemist-mode-hook
          (lambda ()
            (add-to-list (make-local-variable 'company-backends)
                         'alchemist-company)))

(add-hook 'alchemist-iex-mode-hook
          (lambda ()
            (add-to-list (make-local-variable 'company-backends)
                         'alchemist-company)))

(provide 'alchemist-company)

;;; alchemist-company.el ends here
alchemist-20180312.1304/alchemist-pkg.el0000664000175000017500000000106014133447044016056 0ustar  kimrkimr(define-package "alchemist" "20180312.1304" "Elixir tooling integration into Emacs"
  '((elixir-mode "2.2.5")
    (dash "2.11.0")
    (emacs "24.4")
    (company "0.8.0")
    (pkg-info "0.4")
    (s "1.11.0"))
  :commit "6f99367511ae209f8fe2c990779764bbb4ccb6ed" :authors
  '(("Samuel Tonini" . "tonini.samuel@gmail.com"))
  :maintainer
  '("Samuel Tonini" . "tonini.samuel@gmail.com")
  :keywords
  '("languages" "elixir" "elixirc" "mix" "hex" "alchemist")
  :url "http://www.github.com/tonini/alchemist.el")
;; Local Variables:
;; no-byte-compile: t
;; End:
alchemist-20180312.1304/alchemist.el0000664000175000017500000003021614133447044015304 0ustar  kimrkimr;;; alchemist.el --- Elixir tooling integration into Emacs

;; Copyright © 2014-2017 Samuel Tonini
;;
;; Author: Samuel Tonini <tonini.samuel@gmail.com>
;; Maintainer: Samuel Tonini <tonini.samuel@gmail.com>
;; URL: http://www.github.com/tonini/alchemist.el
;; Version: 1.8.2
;; Package-Requires: ((elixir-mode "2.2.5") (dash "2.11.0") (emacs "24.4") (company "0.8.0") (pkg-info "0.4") (s "1.11.0"))
;; Keywords: languages, elixir, elixirc, mix, hex, alchemist

;; 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:
;;
;;  What Does Alchemist Do For You?
;;
;;    Alchemist brings you all the Elixir tooling and power inside your Emacs editor.
;;
;;  Alchemist comes with a bunch of features, which are:
;;
;;    * Mix integration
;;    * Compile & Execution of Elixir code
;;    * Inline code evaluation
;;    * Inline macro expanding
;;    * Documentation lookup
;;    * Definition lookup
;;    * Powerful IEx integration
;;    * Smart code completion
;;    * Elixir project management
;;    * Phoenix support

;;; Code:

;; Tell the byte compiler about autoloaded functions from packages
(declare-function pkg-info-version-info "pkg-info" (package))

(defgroup alchemist nil
  "Elixir Tooling Integration Into Emacs."
  :prefix "alchemist-"
  :group 'applications
  :link '(url-link :tag "Website" "http://www.alchemist-elixir.org")
  :link '(url-link :tag "Github" "https://github.com/tonini/alchemist.el")
  :link '(emacs-commentary-link :tag "Commentary" "alchemist"))

(defvar alchemist-mode-keymap nil)

(require 'easymenu)
(require 'company)
(require 'elixir-mode)
(require 'alchemist-utils)
(require 'alchemist-key)
(require 'alchemist-eval)
(require 'alchemist-goto)
(require 'alchemist-info)
(require 'alchemist-report)
(require 'alchemist-mix)
(require 'alchemist-hex)
(require 'alchemist-hooks)
(require 'alchemist-message)
(require 'alchemist-iex)
(require 'alchemist-compile)
(require 'alchemist-refcard)
(require 'alchemist-complete)
(require 'alchemist-company)
(require 'alchemist-macroexpand)
(require 'alchemist-phoenix)

(defun alchemist-mode-hook ()
  "Hook which enables `alchemist-mode'"
  (alchemist-mode 1))

(defun alchemist-version (&optional show-version)
  "Get the Alchemist version as string.

If called interactively or if SHOW-VERSION is non-nil, show the
version in the echo area and the messages buffer.

The returned string includes both, the version from package.el
and the library version, if both a present and different.

If the version number could not be determined, signal an error,
if called interactively, or if SHOW-VERSION is non-nil, otherwise
just return nil."
  (interactive (list t))
  (let ((version (pkg-info-version-info 'alchemist)))
    (when show-version
      (message "Alchemist version: %s" version))
    version))

(defun alchemist-elixir-version ()
  "Display the current Elixir version on the system."
  (interactive)
  (message "Elixir %s" (alchemist-utils-elixir-version)))

(define-prefix-command 'alchemist-mode-keymap)

;;;###autoload
(define-minor-mode alchemist-mode
  "Toggle alchemist mode.

Key bindings:
\\{alchemist-mode-map}"
  nil
  ;; The indicator for the mode line.
  " alchemist"
  :group 'alchemist
  :global nil
  :keymap `((,alchemist-key-command-prefix . alchemist-mode-keymap))
  (cond (alchemist-mode
         (alchemist-server-start-if-not-running)
         (alchemist-test-initialize-modeline))
        (t
         (alchemist-test-reset-modeline))))

(let ((map alchemist-mode-keymap))
  (define-key map (kbd "x") 'alchemist-mix)
  (define-key map (kbd "t") 'alchemist-mix-test)
  (define-key map (kbd "r") 'alchemist-mix-rerun-last-test)

  (define-key map (kbd "m c") 'alchemist-mix-compile)
  (define-key map (kbd "m r") 'alchemist-mix-run)
  (define-key map (kbd "m l") 'alchemist-mix-rerun-last-task)
  (define-key map (kbd "m t f") 'alchemist-mix-test-file)
  (define-key map (kbd "m t b") 'alchemist-mix-test-this-buffer)
  (define-key map (kbd "m t .") 'alchemist-mix-test-at-point)
  (define-key map (kbd "m t s") 'alchemist-mix-test-stale)
  (define-key map (kbd "m t r") 'alchemist-mix-rerun-last-test)

  (define-key map (kbd "c c") 'alchemist-compile)
  (define-key map (kbd "c f") 'alchemist-compile-file)
  (define-key map (kbd "c b") 'alchemist-compile-this-buffer)

  (define-key map (kbd "e e") 'alchemist-execute)
  (define-key map (kbd "e f") 'alchemist-execute-file)
  (define-key map (kbd "e b") 'alchemist-execute-this-buffer)

  (define-key map (kbd "h h") 'alchemist-help)
  (define-key map (kbd "h i") 'alchemist-help-history)
  (define-key map (kbd "h e") 'alchemist-help-search-at-point)
  (define-key map (kbd "h r") 'alchemist-refcard)

  (define-key map (kbd "p s") 'alchemist-project-toggle-file-and-tests)
  (define-key map (kbd "p o") 'alchemist-project-toggle-file-and-tests-other-window)
  (define-key map (kbd "p t") 'alchemist-project-run-tests-for-current-file)
  (define-key map (kbd "p l") 'alchemist-project-find-lib)
  (define-key map (kbd "p f") 'alchemist-project-find-test)

  (define-key map (kbd "i i") 'alchemist-iex-run)
  (define-key map (kbd "i p") 'alchemist-iex-project-run)
  (define-key map (kbd "i l") 'alchemist-iex-send-current-line)
  (define-key map (kbd "i c") 'alchemist-iex-send-current-line-and-go)
  (define-key map (kbd "i r") 'alchemist-iex-send-region)
  (define-key map (kbd "i m") 'alchemist-iex-send-region-and-go)
  (define-key map (kbd "i b") 'alchemist-iex-compile-this-buffer)
  (define-key map (kbd "i R") 'alchemist-iex-reload-module)

  (define-key map (kbd "v l") 'alchemist-eval-current-line)
  (define-key map (kbd "v k") 'alchemist-eval-print-current-line)
  (define-key map (kbd "v j") 'alchemist-eval-quoted-current-line)
  (define-key map (kbd "v h") 'alchemist-eval-print-quoted-current-line)
  (define-key map (kbd "v o") 'alchemist-eval-region)
  (define-key map (kbd "v i") 'alchemist-eval-print-region)
  (define-key map (kbd "v u") 'alchemist-eval-quoted-region)
  (define-key map (kbd "v y") 'alchemist-eval-print-quoted-region)
  (define-key map (kbd "v q") 'alchemist-eval-buffer)
  (define-key map (kbd "v w") 'alchemist-eval-print-buffer)
  (define-key map (kbd "v e") 'alchemist-eval-quoted-buffer)
  (define-key map (kbd "v r") 'alchemist-eval-print-quoted-buffer)
  (define-key map (kbd "v !") 'alchemist-eval-close-popup)

  (define-key map (kbd "o l") 'alchemist-macroexpand-once-current-line)
  (define-key map (kbd "o L") 'alchemist-macroexpand-once-print-current-line)
  (define-key map (kbd "o k") 'alchemist-macroexpand-current-line)
  (define-key map (kbd "o K") 'alchemist-macroexpand-print-current-line)
  (define-key map (kbd "o i") 'alchemist-macroexpand-once-region)
  (define-key map (kbd "o I") 'alchemist-macroexpand-once-print-region)
  (define-key map (kbd "o r") 'alchemist-macroexpand-region)
  (define-key map (kbd "o R") 'alchemist-macroexpand-print-region)
  (define-key map (kbd "o !") 'alchemist-macroexpand-close-popup)

  (define-key map (kbd "f i") 'alchemist-info-datatype-at-point)
  (define-key map (kbd "f t") 'alchemist-info-types-at-point)

  (define-key map (kbd "X i") 'alchemist-hex-info-at-point)
  (define-key map (kbd "X r") 'alchemist-hex-releases-at-point)
  (define-key map (kbd "X R") 'alchemist-hex-releases)
  (define-key map (kbd "X s") 'alchemist-hex-search)
  (define-key map (kbd "X I") 'alchemist-hex-info)
  (define-key map (kbd "X d") 'alchemist-hex-all-dependencies))

(define-key alchemist-mode-map (kbd "M-.") 'alchemist-goto-definition-at-point)
(define-key alchemist-mode-map (kbd "M-,") 'alchemist-goto-jump-back)
(define-key alchemist-mode-map (kbd "C-c , .") 'alchemist-goto-list-symbol-definitions)
(define-key alchemist-mode-map (kbd "M-P") 'alchemist-goto-jump-to-previous-def-symbol)
(define-key alchemist-mode-map (kbd "M-N") 'alchemist-goto-jump-to-next-def-symbol)
(define-key alchemist-mode-map (kbd "C-c M-r") 'alchemist-test-toggle-test-report-display)

(easy-menu-define alchemist-mode-menu alchemist-mode-map
  "Alchemist mode menu."
  '("Alchemist"
    ("Goto"
     ["Jump to definition at point" alchemist-goto-definition-at-point]
     ["Jump back" alchemist-goto-jump-back])
    ("Evaluate"
     ["Evaluate current line" alchemist-eval-current-line]
     ["Evaluate current line and print" alchemist-eval-print-current-line]
     ["Evaluate quoted current line" alchemist-eval-quoted-current-line]
     ["Evaluate quoted current line and print" alchemist-eval-print-quoted-current-line]
     "---"
     ["Evaluate region" alchemist-eval-region]
     ["Evaluate region and print" alchemist-eval-print-region]
     ["Evaluate quoted region" alchemist-eval-quoted-region]
     ["Evaluate quoted region and print" alchemist-eval-print-quoted-region]
     "---"
     ["Evaluate buffer" alchemist-eval-buffer]
     ["Evaluate buffer and print" alchemist-eval-print-buffer]
     ["Evaluate quoted buffer" alchemist-eval-quoted-buffer]
     ["Evaluate quoted buffer and print" alchemist-eval-print-quoted-buffer])
    ("Macroexpand"
     ["Macro expand once current line" alchemist-macroexpand-once-current-line]
     ["Macro expand once current line and print" alchemist-macroexpand-print-current-line]
     ["Macro expand current line" alchemist-macroexpand-current-line]
     ["Macro expand current line and print" alchemist-macroexpand-print-current-line]
     "---"
     ["Macro expand once region" alchemist-macroexpand-once-region]
     ["Macro expand once region and print" alchemist-macroexpand-print-region]
     ["Macro expand region" alchemist-macroexpand-region]
     ["Macro expand region and print" alchemist-macroexpand-print-region])
    ("Compile"
     ["Compile..." alchemist-compile]
     ["Compile this buffer" alchemist-compile-this-buffer]
     ["Compile file" alchemist-compile-file])
    ("Execute"
     ["Execute..." alchemist-compile]
     ["Execute this buffer" alchemist-execute-this-buffer]
     ["Execute file" alchemist-execute-file])
    ("Mix"
     ["Mix compile..." alchemist-mix-compile]
     ["Mix run..." alchemist-mix-run]
     "---"
     ["Mix run whole test suite." alchemist-mix-test]
     ["Mix test this buffer" alchemist-mix-test-this-buffer]
     ["Mix test file..." alchemist-mix-test-file]
     ["Mix test at point" alchemist-mix-test-at-point]
     ["Mix run stale tests (Elixir 1.3+)" alchemist-mix-test-stale]
     "---"
     ["Mix..." alchemist-mix]
     "---"
     ["Display mix buffer" alchemist-mix-display-mix-buffer]
     "---"
     ["Mix help..." alchemist-mix-help])
    ("IEx"
     ["IEx send current line" alchemist-iex-send-current-line]
     ["IEx send current line and go" alchemist-iex-send-current-line-and-go]
     "---"
     ["IEx send last region" alchemist-iex-send-last-sexp]
     ["IEx send region" alchemist-iex-send-region]
     ["IEx send region and go" alchemist-iex-send-region-and-go]
     "---"
     ["IEx compile this buffer" alchemist-iex-compile-this-buffer]
     ["IEx recompile this buffer" alchemist-iex-recompile-this-buffer]
     "---"
     ["IEx run" alchemist-iex-run])
    ("Project"
     ["Project list all files inside test directory" alchemist-project-find-test]
     ["Project list all files inside lib directory" alchemist-project-find-lib]
     ["Project toggle between file and test" alchemist-project-toggle-file-and-tests]
     ["Project toggle between file and test in other window" alchemist-project-toggle-file-and-tests-other-window])
    ("Documentation"
     ["Documentation search..." alchemist-help]
     ["Documentation search history..." alchemist-help-history]
     "---"
     ["Documentation search at point..." alchemist-help-search-at-point])
    ("About"
     ["Show Alchemist version" alchemist-version t])))

(add-hook 'elixir-mode-hook 'alchemist-mode-hook)

(provide 'alchemist)

;;; alchemist.el ends here
alchemist-20180312.1304/alchemist-mix.el0000664000175000017500000002006514133447044016100 0ustar  kimrkimr;;; alchemist-mix.el --- Interface to run Elixir mix tasks inside Emacs

;; Copyright © 2014-2017 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:

;; Interface to run Elixir mix tasks inside Emacs.

;;; Code:

(require 'alchemist-utils)
(require 'alchemist-project)
(require 'alchemist-test-mode)
(require 'alchemist-server)

(defgroup alchemist-mix nil
  "Emacs integration for Elixir's mix."
  :prefix "alchemist-mix-"
  :group 'alchemist)

;; Variables

(defvar alchemist-last-run-test nil)
(defvar alchemist-mix-filter-output nil)
(defvar alchemist-mix-last-task-command nil)

(defcustom alchemist-mix-command "mix"
  "The shell command for mix."
  :type 'string
  :group 'alchemist-mix)

(defcustom alchemist-mix-test-task "test"
  "Default task to run tests."
  :type 'string
  :group 'alchemist-mix)

(defcustom alchemist-mix-test-default-options '()
  "Default options for alchemist test command."
  :type '(repeat string)
  :group 'alchemist-mix)

(defcustom alchemist-mix-env nil
  "The default mix env to run mix commands with.  If nil, the mix env is
not set explicitly."
  :type '(string boolean)
  :group 'alchemist-mix)

(defvar alchemist-mix-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "q" #'quit-window)
    (define-key map "i" #'alchemist-mix-send-input-to-mix-process)
    (define-key map "r" #'alchemist-mix-rerun-last-task)
    map))

(defvar alchemist-mix-buffer-name "*alchemist mix*"
  "Name of the mix output buffer.")

(defvar alchemist-mix--envs '("dev" "prod" "test")
  "The list of mix envs to use as defaults.")

(defconst alchemist-mix-process-name "alchemist-mix-report"
  "Name of the mix process.")

;; Private functions

(defun alchemist-mix--completing-read (prompt cmdlist)
  (completing-read prompt cmdlist nil t nil nil (car cmdlist)))

(defun alchemist-mix--execute-test (&optional what)
  "Execute 'mix test' on the given `WHAT'.

`WHAT' could be a filename, a filename:line string or the empty string (meaning
run all tests)."
  (if what
      (setq alchemist-last-run-test what)
    (setq alchemist-last-run-test ""))
  (alchemist-test-execute (list alchemist-mix-command
                                alchemist-mix-test-task
                                what
                                alchemist-mix-test-default-options)))

(defun alchemist-mix--test-file (filename)
  "Run a specific FILENAME as argument for the mix command test."
  (when (not (file-exists-p filename))
    (error "The given file doesn't exist"))
  (alchemist-mix--execute-test (expand-file-name filename)))

;; Public functions

(defun alchemist-mix ()
  "Prompt for a specific mix task to run.

If the command `universal-argument' is called before `alchemist-mix',
a prompt for a specific mix environment in which the task will be
executed, gets called."
  (interactive)
  (alchemist-server-info "{ :type, :mixtasks }" #'alchemist-mix-filter))

(defun alchemist-mix-display-mix-buffer ()
  "Display the mix buffer when exists."
  (interactive)
  (when (get-buffer alchemist-mix-buffer-name)
    (display-buffer alchemist-mix-buffer-name)))

(defun alchemist-mix-test ()
  "Run the whole elixir test suite."
  (interactive)
  (alchemist-mix--execute-test))

(defun alchemist-mix-test-stale ()
  "Run stale tests (Elixir 1.3+ only)."
  (interactive)
  (if (alchemist-utils-elixir-version-check-p 1 3 0)
      (alchemist-mix--execute-test "--stale")
    (progn (message "Elixir needs to be >= 1.3.0 for mix test --stale")
           (alchemist-mix-test))))

(defun alchemist-mix-test-this-buffer ()
  "Run the current buffer through mix test."
  (interactive)
  (alchemist-mix--test-file buffer-file-name))

(defun alchemist-mix-test-file (filename)
  "Run `alchemist-mix--test-file' with the FILENAME."
  (interactive "Fmix test: ")
  (alchemist-mix--test-file (expand-file-name filename)))

(defun alchemist-mix-test-at-point ()
  "Run the test at point."
  (interactive)
  (let* ((line (line-number-at-pos (point)))
         (file-and-line (format "%s:%s" buffer-file-name line)))
    (alchemist-mix--execute-test file-and-line)))

(defun alchemist-mix-rerun-last-test ()
  "Rerun the last test that was run by alchemist.

When no tests had been run before calling this function, do nothing."
  (interactive)
  (if alchemist-last-run-test
      (alchemist-mix--execute-test alchemist-last-run-test)
    (message "No tests have been run yet")))

(defun alchemist-mix-compile (command &optional prefix)
  "Compile the whole elixir project. Prompt for the mix env if the prefix
arg is set."
  (interactive "Mmix compile: \nP")
  (alchemist-mix-execute (list "compile" command) prefix))

(defun alchemist-mix-run (command &optional prefix)
  "Runs the given file or expression in the context of the application."
  (interactive "Mmix run: \nP")
  (alchemist-mix-execute (list "run" command) prefix))

(defun alchemist-mix-send-input-to-mix-process (input)
  "Send INPUT to the current running mix task process."
  (interactive "MSend to running mix task: ")
  (let* ((buffer (get-buffer alchemist-mix-buffer-name))
         (process (get-buffer-process buffer)))
    (if (and process (eq (process-status process) 'run))
        (with-current-buffer buffer
          (let ((inhibit-read-only t))
            (goto-char (point-max))
            (insert (concat input "\n\n"))
            (set-marker (process-mark process) (point)))
          (comint-send-string process (concat input "\n")))
      (error "No %s process is running" alchemist-mix-buffer-name))))

(defun alchemist-mix-rerun-last-task ()
  "Rerun the last mix task which was run by alchemist.
When no mix task had been run before calling this function, do nothing."
  (interactive)
  (if alchemist-mix-last-task-command
      (alchemist-report-run alchemist-mix-last-task-command
			    alchemist-mix-process-name
			    alchemist-mix-buffer-name 'alchemist-mix-mode)
    (message "No mix task have been run yet")))

(defun alchemist-mix-filter (_process output)
  (with-local-quit
    (setq alchemist-mix-filter-output (cons output alchemist-mix-filter-output))
    (when (alchemist-server-contains-end-marker-p output)
      (let* ((output (alchemist-server-prepare-filter-output alchemist-mix-filter-output))
             (tasks (split-string output "\n"))
             (selected-task (alchemist-mix--completing-read "mix: " (-distinct tasks)))
             (command (read-shell-command "mix " (concat selected-task " "))))
        (setq alchemist-mix-filter-output nil)
        (alchemist-mix-execute (list command) current-prefix-arg)))))

(define-derived-mode alchemist-mix-mode fundamental-mode "Mix Mode"
  "Major mode for presenting Mix tasks.

\\{alchemist-mix-mode-map}"
  (setq buffer-read-only t)
  (setq-local truncate-lines t)
  (setq-local electric-indent-chars nil))

(defun alchemist-mix-execute (command-list &optional prefix)
  "Run a mix task specified by COMMAND-LIST.

If PREFIX is non-nil, prompt for a mix environment variable."
  (let* ((mix-env (if prefix
                      (completing-read "mix env: " alchemist-mix--envs nil nil alchemist-mix-env)
                    alchemist-mix-env))
         (command (alchemist-utils-build-command
                   (list (when mix-env (concat "MIX_ENV=" mix-env))
                         alchemist-mix-command command-list))))
    (setq alchemist-mix-last-task-command command)
    (alchemist-report-run command alchemist-mix-process-name alchemist-mix-buffer-name 'alchemist-mix-mode)))

(provide 'alchemist-mix)

;;; alchemist-mix.el ends here
alchemist-20180312.1304/alchemist-refcard.el0000664000175000017500000003142414133447044016712 0ustar  kimrkimr;;; alchemist-refcard.el --- Generates a refcard of alchemist functionality

;; Copyright © 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:

;; Generates a refcard of alchemist functionality

;;; Code:

(require 'cl-lib)
(require 'dash)
(require 's)
(require 'tabulated-list)
(require 'alchemist-phoenix)

;; Tell the byte compiler about autoloaded functions from packages
(eval-when-compile
  (declare-function alchemist-mode "alchemist.el")
  (declare-function alchemist-version "alchemist.el"))

(defgroup alchemist-refcard nil
  "Generate a refcard of alchemist functionality."
  :prefix "alchemist-"
  :group 'applications)

(defconst alchemist-refcard--buffer-name "*alchemist-refcard*"
  "Name of Alchemist-Refcard mode buffer.")

(defconst alchemist-refcard-list-format
  [("" 55 t)
   ("" 35 t)]
  "List format.")

(defvar alchemist-refcard-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "i") 'alchemist-refcard--describe-funtion-at-point)
    (define-key map (kbd "q") 'quit-window)
    map)
  "Keymap for `alchemist-refcard-mode'.")

(defun alchemist-refcard--get-keybinding (function-name)
  (let* ((keys (where-is-internal (intern function-name)))
         (keys (-map (lambda (k)
                       (let ((key (format "%s" k)))
                         (if (string-match-p "menu-bar" key)
                             nil
                           k))) keys))
         (keys (-remove 'null keys)))
    (if keys
        (progn
          (mapconcat (lambda (k) (key-description k)) keys " , "))
      "")))

(defun alchemist-refcard--tabulated-list-entries ()
  (alchemist-mode +1) ;; needs to be enabled for fetching current keybindings
  (let ((rows (list (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-refcard-title-row (format "Alchemist Refcard v%s" (alchemist-version)))
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Mix")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-compile")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-run")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Hex")
                    (alchemist-refcard--build-tabulated-row "alchemist-hex-info-at-point")
                    (alchemist-refcard--build-tabulated-row "alchemist-hex-releases-at-point")
                    (alchemist-refcard--build-tabulated-row "alchemist-hex-releases")
                    (alchemist-refcard--build-tabulated-row "alchemist-hex-info")
                    (alchemist-refcard--build-tabulated-row "alchemist-hex-search")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Testing")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-test")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-rerun-last-test")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-test-file")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-test-this-buffer")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-test-at-point")
                    (alchemist-refcard--build-tabulated-row "alchemist-mix-test-stale")
                    (alchemist-refcard--build-tabulated-row "alchemist-test-toggle-test-report-display")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Compilation")
                    (alchemist-refcard--build-tabulated-row "alchemist-compile")
                    (alchemist-refcard--build-tabulated-row "alchemist-compile-file")
                    (alchemist-refcard--build-tabulated-row "alchemist-compile-this-buffer")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Execution")
                    (alchemist-refcard--build-tabulated-row "alchemist-execute")
                    (alchemist-refcard--build-tabulated-row "alchemist-execute-file")
                    (alchemist-refcard--build-tabulated-row "alchemist-execute-this-buffer")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Documentation Lookup")
                    (alchemist-refcard--build-tabulated-row "alchemist-help")
                    (alchemist-refcard--build-tabulated-row "alchemist-help-history")
                    (alchemist-refcard--build-tabulated-row "alchemist-help-search-at-point")
                    (alchemist-refcard--build-tabulated-row "alchemist-refcard")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Definition Lookup")
                    (alchemist-refcard--build-tabulated-row "alchemist-goto-definition-at-point")
                    (alchemist-refcard--build-tabulated-row "alchemist-goto-jump-back")
                    (alchemist-refcard--build-tabulated-row "alchemist-goto-jump-to-previous-def-symbol")
                    (alchemist-refcard--build-tabulated-row "alchemist-goto-jump-to-next-def-symbol")
                    (alchemist-refcard--build-tabulated-row "alchemist-goto-list-symbol-definitions")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Project")
                    (alchemist-refcard--build-tabulated-row "alchemist-project-find-test")
                    (alchemist-refcard--build-tabulated-row "alchemist-project-toggle-file-and-tests")
                    (alchemist-refcard--build-tabulated-row "alchemist-project-toggle-file-and-tests-other-window")
                    (alchemist-refcard--build-tabulated-row "alchemist-project-run-tests-for-current-file")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "IEx")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-run")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-project-run")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-send-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-send-current-line-and-go")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-send-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-send-region-and-go")
                    (alchemist-refcard--build-tabulated-row "alchemist-iex-compile-this-buffer")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Eval")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-quoted-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-quoted-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-quoted-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-quoted-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-buffer")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-buffer")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-quoted-buffer")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-print-quoted-buffer")
                    (alchemist-refcard--build-tabulated-row "alchemist-eval-close-popup")
                    (alchemist-refcard--build-empty-tabulated-row)
                    (alchemist-refcard--build-tabulated-title-row "Macroexpand")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-once-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-once-print-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-print-current-line")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-once-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-once-print-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-print-region")
                    (alchemist-refcard--build-tabulated-row "alchemist-macroexpand-close-popup")
                    (alchemist-phoenix-mode) ;; needs to be enabled for fetching current keybindings
                    (alchemist-refcard--build-tabulated-title-row "Phoenix-Mode")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-web")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-views")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-controllers")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-channels")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-templates")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-models")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-static")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-router")
                    (alchemist-refcard--build-tabulated-row "alchemist-phoenix-find-routes")
                    (alchemist-refcard--build-empty-tabulated-row))))
    ;; disable it after getting the current keybindings
    (alchemist-phoenix-mode -1)
    (alchemist-mode -1)
    rows))

(defun alchemist-refcard--build-empty-tabulated-row ()
  (list "" `[,"" ""]))

(defun alchemist-refcard--build-tabulated-row (function-name)
  (list function-name `[,function-name
                        ,(propertize (alchemist-refcard--get-keybinding function-name) 'face font-lock-builtin-face)]))

(defun alchemist-refcard--build-tabulated-refcard-title-row (title)
  (list "" `[,(propertize title 'face font-lock-variable-name-face) ""]))

(defun alchemist-refcard--build-tabulated-title-row (title)
  (list "" `[,(propertize title 'face font-lock-constant-face) ""]))

(defun alchemist-refcard--describe-funtion-at-point ()
  (interactive)
  (let ((function-name (get-text-property (point) 'tabulated-list-id)))
    (when (not (s-blank? function-name))
      (describe-function (intern function-name)))))

(defun alchemist-refcard--buffer ()
  "Return alchemist-refcard buffer if it exists."
  (get-buffer alchemist-refcard--buffer-name))

(define-derived-mode alchemist-refcard-mode tabulated-list-mode "Alchemist"
  "Alchemist refcard mode."
  (buffer-disable-undo)
  (kill-all-local-variables)
  (setq truncate-lines t)
  (setq mode-name "Alchemist-Refcard")
  (setq-local alchemist-test-status-modeline nil)
  (use-local-map alchemist-refcard-mode-map)
  (setq tabulated-list-format alchemist-refcard-list-format)
  (setq tabulated-list-entries 'alchemist-refcard--tabulated-list-entries)
  (tabulated-list-print))

;;;###autoload
(defun alchemist-refcard ()
  "Generate an Alchemist refcard of all the features."
  (interactive)
  (let ((buffer-p (alchemist-refcard--buffer))
        (buffer (get-buffer-create alchemist-refcard--buffer-name)))
    (pop-to-buffer buffer)
    (unless buffer-p
      (alchemist-refcard-mode))))

(provide 'alchemist-refcard)

;;; alchemist-refcard.el ends here
alchemist-20180312.1304/alchemist-server.el0000664000175000017500000002051714133447044016613 0ustar  kimrkimr;;; alchemist-server.el --- Interface to the Alchemist Elixir server. -*- lexical-binding: t -*-

;; Copyright © 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:

;; Interface to the Alchemist Elixir server.

;;; Code:

(require 'alchemist-execute)

(defgroup alchemist-server nil
  "Interface to the Alchemist Elixir server."
  :prefix "alchemist-server-"
  :group 'alchemist)

(defvar alchemist-server-processes '()
  "Store running Alchemist server processes.")

(defvar alchemist-server-env "dev"
  "Default environment in for the Alchemist server.")

(defvar alchemist-server-envs '("dev" "prod" "test" "shared")
  "List of available Alchemist server environments.")

(defconst alchemist-server
  (concat (file-name-directory load-file-name) "alchemist-server/run.exs")
  "Path to the Alchemist server file.")

(defconst alchemist-server-command
  (format "%s %s %s"
          alchemist-execute-command
          alchemist-server
          alchemist-server-env)
  "Alchemist server command.")

(defconst alchemist-server-codes '((server-eval "EVAL")
                                   (server-defl "DEFL")
                                   (server-info "INFO")
                                   (server-docl "DOCL")
                                   (server-comp "COMP"))
  "Alchemist server API codes.")

(defun alchemist-server-start (env)
  "Start alchemist server for the current mix project in specific ENV.

If a server already running, the current one will be killed and new one
will be started instead."
  (interactive (list
                (completing-read (format "(Alchemist-Server) run in environment: (default: %s) " alchemist-server-env)
                                 alchemist-server-envs nil nil nil)))
  (when (alchemist-server-process-p)
    (kill-process (alchemist-server-process)))
  (alchemist-server-start-in-env env))

(defun alchemist-server-start-if-not-running ()
  "Start a new Alchemist server if not already running.

An Alchemist server will be started for the current Elixir mix project."
  (unless (alchemist-server-process-p)
    (alchemist-server-start-in-env alchemist-server-env)))

(defun alchemist-server-start-in-env (env)
  "Start an Alchemist server with the ENV."
  (let* ((process-name (alchemist-server-process-name))
         (default-directory (if (string= process-name "alchemist-server")
                                default-directory
                              process-name))
         (server-command (format "%s %s %s"
                                 alchemist-execute-command
                                 (shell-quote-argument alchemist-server)
                                 (shell-quote-argument env)))
         (process (start-process-shell-command process-name "*alchemist-server*" server-command)))
    (set-process-query-on-exit-flag process nil)
    (alchemist-server--store-process process)))

(defun alchemist-server--store-process (process)
  "Store PROCESS in `alchemist-server-processes'."
  (let ((process-name (alchemist-server-process-name)))
    (if (cdr (assoc process-name alchemist-server-processes))
        (setq alchemist-server-processes
              (delq (assoc process-name alchemist-server-processes) alchemist-server-processes)))
    (add-to-list 'alchemist-server-processes (cons process-name process))))

(defun alchemist-server-process-p ()
  "Return non-nil if a process for the current
Elixir mix project is live."
  (process-live-p (alchemist-server-process)))

(defun alchemist-server-process ()
  "Return process for the current Elixir mix project."
  (cdr (assoc (alchemist-server-process-name) alchemist-server-processes)))

(defun alchemist-server-process-name ()
  "Return process name for the current Elixir mix project."
  (let* ((process-name (if (alchemist-project-elixir-p)
                           "alchemist-server"
                         (alchemist-project-root)))
         (process-name (if process-name
                           process-name
                         "alchemist-server")))
    process-name))

(defun alchemist-server-api-code (symbol)
  "Return Alchemist server API code for SYMBOL."
  (car (cdr (assoc symbol alchemist-server-codes))))

(defconst alchemist-server-code-end-marker-regex
  (format "END-OF-\\(%s\\|%s\\|%s\\|%s\\|%s\\)$"
          (alchemist-server-api-code 'server-eval)
          (alchemist-server-api-code 'server-defl)
          (alchemist-server-api-code 'server-info)
          (alchemist-server-api-code 'server-docl)
          (alchemist-server-api-code 'server-comp))
  "Regular expression to identify Alchemist server API end markers.")

(defun alchemist-server-contains-end-marker-p (string)
  "Return non-nil if STRING contain an Alchemist server API end marker."
  (when string
    (string-match-p alchemist-server-code-end-marker-regex string)))

(defun alchemist-server-build-request-string (code &optional args)
  "Build Alchemist server request string for CODE.

If ARGS available add them to the request string."
  (let* ((code (car (cdr (assoc code alchemist-server-codes)))))
    (if args
        (format "%s %s\n" code args)
      (format "%s\n" code))))

(defun alchemist-server-prepare-filter-output (output)
  "Clean OUTPUT by remove Alchemist server API end markes."
  (let* ((output (apply #'concat (reverse output)))
         (output (replace-regexp-in-string alchemist-server-code-end-marker-regex "" output))
         (output (replace-regexp-in-string "\n+$" "" output)))
    output))

(defun alchemist-server-send-request (string filter)
  "Send STRING to Alchemist server API and set FILTER to process."
  (alchemist-server-start-if-not-running)
  (set-process-filter (alchemist-server-process) filter)
  (process-send-string (alchemist-server-process) string))

(defun alchemist-server-goto (args filter)
  "Make an Alchemist server source request with ARGS.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-defl args) filter))

(defun alchemist-server-info (args filter)
  "Make an Alchemist server mix request.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-info args) filter))

(defun alchemist-server-help-with-modules (filter)
  "Make an Alchemist server modules request.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-info) filter))

(defun alchemist-server-help (args filter)
  "Make an Alchemist server doc request with ARGS.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-docl args) filter))

(defun alchemist-server-eval (args filter)
  "Make an Alchemist server evaluate request with FILE.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-eval args) filter))

(defun alchemist-server-complete-candidates (args filter)
  "Make an Alchemist server complete request with ARGS.

Process server respond with FILTER."
  (alchemist-server-start-if-not-running)
  (alchemist-server-send-request (alchemist-server-build-request-string 'server-comp args) filter))

(defun alchemist-server-status ()
  "Report the server status for the current Elixir project."
  (interactive)
  (message "Alchemist-Server-Status: [Project: %s Status: %s]"
           (alchemist-server-process-name)
           (if (alchemist-server-process-p)
               "Connected"
             "Not Connected")))

(provide 'alchemist-server)

;;; alchemist-server.el ends here
alchemist-20180312.1304/alchemist-utils.el0000664000175000017500000001462714133447044016452 0ustar  kimrkimr;;; alchemist-utils.el --- Common utility functions that don't belong anywhere else -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

;; Common utility functions that don't belong anywhere else

;;; Code:

(require 'cl-lib)
(require 'dash)
(require 's)

(defun alchemist-utils-build-command (command-list)
  "Build the commands list for the runner."
  (let* ((command-list (-flatten (if (stringp command-list)
                                     (split-string command-list)
                                   command-list)))
         (command (-remove (lambda (e) (equal e "")) command-list)))
    (mapconcat 'concat command " ")))

(defun alchemist-utils-count-char-occurence (regexp str)
  "Count occurrence of char with REGEXP inside STR."
  (cl-loop with start = 0
           for count from 0
           while (string-match regexp str start)
           do (setq start (match-end 0))
           finally return count))

(defun alchemist-utils-test-file-p ()
  "Return non-nil `current-buffer' holds an Elixir test file."
  (string-match "_test\\.exs$" (or (buffer-file-name) "")))

(defun alchemist-utils-remove-dot-at-the-end (string)
  "Remove dot character at the end of STRING."
  (replace-regexp-in-string "\\.$" "" string))

(defun alchemist-utils-prepare-aliases-for-elixir (aliases)
  (let* ((aliases (-map (lambda (a)
                            (let ((module (alchemist-utils-remove-dot-at-the-end (car a)))
                                  (alias (alchemist-utils-remove-dot-at-the-end (car (cdr a)))))
                            (if (not (or (s-blank? alias)
                                         (string= alias module)))
                                (format "{%s, %s}"
                                        (if (s-blank? alias)
                                            module
                                          alias)
                                        module)))) aliases))
         (aliases (mapconcat #'identity aliases ",")))
    (format "[%s]" aliases)))

(defun alchemist-utils-prepare-modules-for-elixir (modules)
  (let* ((modules (mapconcat #'identity modules ",")))
    (format "[%s]" modules)))

(defun alchemist-utils--snakecase-to-camelcase (str)
  "Convert a snake_case string STR to a CamelCase string.

This function is useful for converting file names like my_module to Elixir
module names (MyModule)."
  (mapconcat 'capitalize (split-string str "_") ""))

(defun alchemist-utils-add-ext-to-path-if-not-present (path ext)
  "Add EXT to PATH if PATH doesn't already ends with EXT."
  (if (string-suffix-p ext path)
      path
    (concat path ext)))

(defun alchemist-utils-path-to-module-name (path)
  "Convert PATH to its Elixir module name equivalent.

For example, convert 'my_app/my_module.ex' to 'MyApp.MyModule'."
  (let* ((path (file-name-sans-extension path))
         (path (split-string path "/"))
         (path (-remove (lambda (str) (equal str "")) path)))
    (mapconcat #'alchemist-utils--snakecase-to-camelcase path ".")))

(defun alchemist-utils-add-trailing-slash (path)
  "Add trailing slash to PATH if not already contain."
  (if (not (string-match-p "/$" path))
      (format "%s/" path)
    path))

(defun alchemist-utils-occur-in-buffer-p (buffer regex)
  "Return non-nil if BUFFER contains at least one occurrence of REGEX."
  (with-current-buffer buffer
    (save-excursion
      (save-match-data
        (goto-char (point-min))
        (re-search-forward regex nil t)))))

(defun alchemist-utils-jump-to-regex (regex before-fn after-fn search-fn reset-fn)
  "Jump to REGEX using SEARCH-FN to search for it.
A common use case would be to use `re-search-forward' as the SEARCH-FN.
Call RESET-FN if the regex isn't found at the first try. BEFORE-FN is called
before performing the search while AFTER-FN after."
  (when (alchemist-utils-occur-in-buffer-p (current-buffer) regex)
    (save-match-data
      (funcall before-fn)
      (unless (funcall search-fn regex nil t)
        (funcall reset-fn)
        (funcall search-fn regex nil t))
      (funcall after-fn))))

(defun alchemist-utils-jump-to-next-matching-line (regex after-fn)
  "Jump to the next line matching REGEX.
Call AFTER-FN after performing the search."
  (alchemist-utils-jump-to-regex regex 'end-of-line after-fn 're-search-forward 'beginning-of-buffer))

(defun alchemist-utils-jump-to-previous-matching-line (regex after-fn)
  "Jump to the previous line matching REGEX.

Call AFTER-FN after performing the search."
  (alchemist-utils-jump-to-regex regex 'beginning-of-line after-fn 're-search-backward 'end-of-buffer))

(defun alchemist-utils-elixir-version ()
  "Return the current Elixir version on the system."
  (let* ((output (shell-command-to-string (format "%s --version" alchemist-execute-command)))
         (output (split-string output "\n"))
         (output (-remove (lambda (string) (s-blank? string))
                          output))
         (version (-last-item output))
         (version (replace-regexp-in-string "Elixir " "" version)))
    version))

(defun alchemist-utils-elixir-version-check-p (major minor tiny &optional version)
  "Returns t if the current elixir version is greater than or equal to the supplied version"
  (let* ((version-string (or version (alchemist-utils-elixir-version)))
         (version-list (split-string version-string "\\."))
         (current-major (string-to-number (car version-list)))
         (current-minor (string-to-number (car (cdr version-list))))
         (current-tiny (string-to-number (car (cdr (cdr version-list))))))
    (if (> current-major major)
        t
      (if (and (= current-major major) (> current-minor minor))
          t
        (and (= current-minor minor) (>= current-tiny tiny))))))

(provide 'alchemist-utils)

;;; alchemist-utils.el ends here
alchemist-20180312.1304/alchemist-test-mode.el0000664000175000017500000003511014133447044017201 0ustar  kimrkimr;;; alchemist-test-mode.el --- Minor mode for Elixir test files.

;; Copyright © 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:

;; Minor mode for Elixir test files.

;;; Code:

(require 'dash)
(require 'alchemist-project)

(defgroup alchemist-test-mode nil
  "Minor mode for Elixir ExUnit files."
  :prefix "alchemist-test-mode-"
  :group 'alchemist)

;; Variables

(defcustom alchemist-test-mode-highlight-tests t
  "Non-nil means that specific functions for testing will
be highlighted with more significant font faces."
  :type 'boolean
  :group 'alchemist-test-mode)

(defcustom alchemist-test-display-compilation-output nil
  "if Non-nil, compilation informations will be displayed
in the test report buffer."
  :type 'boolean
  :group 'alchemist-test-mode)

(defcustom alchemist-test-truncate-lines t
  "The value of this variable is used to set the value of
truncate-lines in the test report window."
  :type 'boolean
  :group 'alchemist-test-mode)

(defcustom alchemist-test-status-modeline t
  "if Non-nil, the face of local `mode-name' variable will change with test run status.

For example, when `alchemist-mix-test' fails, the `mode-name' will be
formatted with the `alchemist-test--failed-face' face, to symbolize failing tests."
  :type 'boolean
  :group 'alchemist-test)

(defcustom alchemist-test-ask-about-save t
  "Non-nil means 'alchemist-test-excute` asks which buffers to save before running.
Otherwise, it saves all modified buffers without asking."
  :type 'boolean
  :group 'alchemist-test)

(defvar alchemist-test--last-run-status "")

(defconst alchemist-test-report-buffer-name "*alchemist test report*"
  "Name of the test report buffer.")

(defconst alchemist-test-report-process-name "alchemist-test-process"
  "Name of the test report process.")

(defconst alchemist-test--failing-files-regex
  "\\( *[0-9]+).+\n\s+\\)\\([-A-Za-z0-9./_]+:[0-9]+\\)$")
(defconst alchemist-test--stacktrace-files-regex
  "\\( *\\)\\([-A-Za-z0-9./_]+:[0-9]+\\): (test)")

;; Faces

(defface alchemist-test--test-file-and-location-face
  '((t (:inherit font-lock-variable-name-face :weight bold)))
  "Face for the file where the failed test are."
  :group 'alchemist-test)

(defface alchemist-test--stacktrace-file-and-location-face
  '((t (:inherit font-lock-keyword-face :weight bold)))
  "Face for the stacktrace files."
  :group 'alchemist-test)

(defface alchemist-test--success-face
  '((t (:inherit font-lock-variable-name-face :bold t :background "darkgreen" :foreground "white")))
  "Face for successful compilation run."
  :group 'alchemist-test)

(defface alchemist-test--failed-face
  '((t (:inherit font-lock-variable-name-face :bold t :background "red" :foreground "white")))
  "Face for failed compilation run."
  :group 'alchemist-test)

(defvar alchemist-test--mode-name-face 'mode-line)

(defvar alchemist-test-at-point #'alchemist-mix-test-at-point)
(defvar alchemist-test-this-buffer #'alchemist-mix-test-this-buffer)
(defvar alchemist-test #'alchemist-mix-test)
(defvar alchemist-test-file #'alchemist-mix-test-file)
(defvar alchemist-test-jump-to-previous-test #'alchemist-test-mode-jump-to-previous-test)
(defvar alchemist-test-jump-to-next-test #'alchemist-test-mode-jump-to-next-test)
(defvar alchemist-test-list-tests #'alchemist-test-mode-list-tests)

(defvar alchemist-test-report-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "q" #'quit-window)
    (define-key map "t" #'toggle-truncate-lines)
    (define-key map "r" #'alchemist-mix-rerun-last-test)
    (define-key map (kbd "M-n") #'alchemist-test-next-result)
    (define-key map (kbd "M-p") #'alchemist-test-previous-result)
    (define-key map (kbd "M-N") #'alchemist-test-next-stacktrace-file)
    (define-key map (kbd "M-P") #'alchemist-test-previous-stacktrace-file)
    (define-key map (kbd "C-c C-k") #'alchemist-report-interrupt-current-process)
    map))

(defvar alchemist-test-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "C-c , s") alchemist-test-at-point)
    (define-key map (kbd "C-c , v") alchemist-test-this-buffer)
    (define-key map (kbd "C-c , a") alchemist-test)
    (define-key map (kbd "C-c , f") alchemist-test-file)
    (define-key map (kbd "C-c , p") alchemist-test-jump-to-previous-test)
    (define-key map (kbd "C-c , n") alchemist-test-jump-to-next-test)
    (define-key map (kbd "C-c , l") alchemist-test-list-tests)
    map)
  "Keymap for `alchemist-test-mode'.")

(defconst alchemist-test-mode--test-regex
  (let ((whitespace-opt "[[:space:]]*")
        (whitespace "[[:space:]]+"))
    (concat "\\(^" whitespace-opt "test" whitespace "\\(?10:.+\\)" whitespace "do" whitespace-opt "$"
            "\\|"
            whitespace " [0-9]+) test .+\\)")))

;; Private functions

(defun alchemist-test--set-modeline-color (status)
  (setq alchemist-test--mode-name-face
        (if (string-prefix-p "finished" status)
            'alchemist-test--success-face
          'alchemist-test--failed-face)))

(defun alchemist-test--render-report (buffer)
  (with-current-buffer buffer
    (let ((inhibit-read-only t))
      (alchemist-test--render-files))))

(defun alchemist-test--render-files ()
  (alchemist-test--render-test-failing-files)
  (alchemist-test--render-stacktrace-files))

(defun alchemist-test--render-test-failing-files ()
  (alchemist-test--render-file alchemist-test--failing-files-regex
                               'alchemist-test--test-file-and-location-face))

(defun alchemist-test--render-stacktrace-files ()
  (alchemist-test--render-file alchemist-test--stacktrace-files-regex
                               'alchemist-test--stacktrace-file-and-location-face))

(defun alchemist-test--render-file (regex face)
  (save-excursion
    (goto-char (point-min))
    (while (re-search-forward regex nil t)
      (let ((file (buffer-substring-no-properties (match-beginning 2) (match-end 2))))
        (goto-char (match-beginning 2))
        (replace-match "" nil nil nil 2)
        (insert-text-button file
                            'face face
                            'file file
                            'follow-link t
                            'action #'alchemist-test--open-file
                            'help-echo "visit the source location")))))

(defun alchemist-test--open-file (button)
  (save-match-data
    (string-match "\\([-A-Za-z0-9./_]+\\):\\([0-9]+\\)" (button-get button 'file))
    (let* ((file-with-line (button-get button 'file))
           (file (substring-no-properties file-with-line (match-beginning 1) (match-end 1)))
           (line (string-to-number (substring-no-properties file-with-line (match-beginning 2) (match-end 2))))
           (file-path (if (file-exists-p file)
                          file
                        (expand-file-name (concat (alchemist-project-root) file)))))
      (with-current-buffer (find-file-other-window file-path)
        (goto-char (point-min))
        (forward-line (- line 1))))))

(defun alchemist-test--handle-exit (status buffer)
  (when alchemist-test-status-modeline
    (alchemist-test--set-modeline-color status))
  (with-current-buffer buffer
    (let ((inhibit-read-only t))
      (alchemist-test--render-files))))

(defun alchemist-test-mode--buffer-contains-tests-p ()
  "Return nil if the current buffer contains no tests, non-nil if it does."
  (alchemist-utils-occur-in-buffer-p (current-buffer) alchemist-test-mode--test-regex))

(defun alchemist-test-mode--tests-in-buffer ()
  "Return an alist of tests in this buffer.

The keys in the list are the test names (e.g., the string passed to the test/2
macro) while the values are the position at which the test matched."
  (save-match-data
    (save-excursion
      (goto-char (point-min))
      (let ((tests '()))
        (while (re-search-forward alchemist-test-mode--test-regex nil t)
          (let* ((position (car (match-data)))
                 (matched-string (match-string 10)))
            (set-text-properties 0 (length matched-string) nil matched-string)
            (add-to-list 'tests (cons matched-string position) t)))
        tests))))

(defun alchemist-test-mode--highlight-syntax ()
  (if alchemist-test-mode-highlight-tests
      (font-lock-add-keywords nil
                              '(("^\s+\\(test\\)\s+" 1
                                 font-lock-variable-name-face t)
                                ("^\s+\\(assert[_a-z]*\\|refute[_a-z]*\\|flunk\\)\s+" 1
                                 font-lock-type-face t)
                                ("^\s+\\(assert[_a-z]*\\|refute[_a-z]*\\|flunk\\)\(" 1
                                 font-lock-type-face t)))))

;; Public functions

(define-derived-mode alchemist-test-report-mode fundamental-mode "Alchemist Test Report"
  "Major mode for presenting Elixir test results.

\\{alchemist-test-report-mode-map}"
  (setq buffer-read-only t)
  (setq-local truncate-lines t)
  (setq-local electric-indent-chars nil))

(defun alchemist-test-save-buffers ()
  "Save some modified file-visiting buffers."
  (save-some-buffers (not alchemist-test-ask-about-save) nil))

(defun alchemist-test-clean-compilation-output (output)
  (if (not alchemist-test-display-compilation-output)
      (with-temp-buffer
        (insert output)
        (delete-matching-lines "^Compiled .+" (point-min) (point-max))
        (delete-matching-lines "^Generated .+" (point-min) (point-max))
        (buffer-substring-no-properties (point-min) (point-max)))
  output))

(defun alchemist-test-execute (command-list)
  (message "Testing...")
  (let* ((command (mapconcat 'concat (-flatten command-list) " ")))
    (alchemist-test-save-buffers)
    (alchemist-report-run command
                          alchemist-test-report-process-name
                          alchemist-test-report-buffer-name
                          'alchemist-test-report-mode
                          #'alchemist-test--handle-exit)))

(defun alchemist-test-initialize-modeline ()
  "Initialize the mode-line face."
  (when alchemist-test-status-modeline
    (setq mode-name
          '(:eval (propertize "Elixir" 'face alchemist-test--mode-name-face)))))

(defun alchemist-test-reset-modeline ()
  "Reset the current mode-line face to default."
  (setq mode-name "Elixir"))

(defun alchemist-test-mode-jump-to-next-test ()
  "Jump to the next ExUnit test. If there are no tests after the current
position, jump to the first test in the buffer. Do nothing if there are no tests
in this buffer."
  (interactive)
  (alchemist-utils-jump-to-next-matching-line alchemist-test-mode--test-regex 'back-to-indentation))

(defun alchemist-test-mode-jump-to-previous-test ()
  "Jump to the previous ExUnit test. If there are no tests before the current
position, jump to the last test in the buffer. Do nothing if there are no tests
in this buffer."
  (interactive)
  (alchemist-utils-jump-to-previous-matching-line alchemist-test-mode--test-regex 'back-to-indentation))

(defun alchemist-test-next-result ()
  "Jump to the next error in the test report.

If there are no error after the current position,
jump to the first error in the test report.
Do nothing if there are no error in this test report."
  (interactive)
  (alchemist-utils-jump-to-next-matching-line alchemist-test--failing-files-regex
                                               'back-to-indentation))

(defun alchemist-test-previous-result ()
  "Jump to the previous error in the test report.

If there are no error before the current position,
jump to the first error in the test report.
Do nothing if there are no error in this test report."
  (interactive)
  (alchemist-utils-jump-to-previous-matching-line alchemist-test--failing-files-regex
                                                   #'(lambda ()
                                                       (forward-line 1)
                                                       (back-to-indentation))))

(defun alchemist-test-next-stacktrace-file ()
  "Jump to the next stacktrace file in the test report.

If there are no stacktrace file after the current position,
jump to the first stacktrace file in the test report.
Do nothing if there are no stacktrace file in this test report."
  (interactive)
  (alchemist-utils-jump-to-next-matching-line alchemist-test--stacktrace-files-regex
                                               'back-to-indentation))

(defun alchemist-test-previous-stacktrace-file ()
  "Jump to the previous stacktrace file in the test report.

If there are no stacktrace file before the current position,
jump to the first stacktrace file in the test report.
Do nothing if there are no stacktrace file in this test report."
  (interactive)
  (alchemist-utils-jump-to-previous-matching-line alchemist-test--stacktrace-files-regex
                                                   'back-to-indentation))

(defun alchemist-test-mode-list-tests ()
  "List ExUnit tests (calls to the test/2 macro) in the current buffer and jump
to the selected one."
  (interactive)
  (let* ((tests (alchemist-test-mode--tests-in-buffer))
         (selected (completing-read "Test: " tests))
         (position (cdr (assoc selected tests))))
    (goto-char position)
    (back-to-indentation)))

(defun alchemist-test-toggle-test-report-display ()
  "Toggle between display or hidding `alchemist-test-report-buffer-name' buffer."
  (interactive)
  (let* ((buffer (get-buffer alchemist-test-report-buffer-name))
         (window (get-buffer-window buffer)))
    (if buffer
        (if window
            (quit-window nil window)
          (display-buffer buffer))
      (message "No Alchemist test report buffer exists."))))

;;;###autoload
(define-minor-mode alchemist-test-mode
  "Minor mode for Elixir ExUnit files.

The following commands are available:

\\{alchemist-test-mode-map}"
  :lighter ""
  :keymap alchemist-test-mode-map
  :group 'alchemist
  (when alchemist-test-mode
    (alchemist-test-mode--highlight-syntax)))

;;;###autoload
(defun alchemist-test-enable-mode ()
  (if (alchemist-utils-test-file-p)
      (alchemist-test-mode)))

;;;###autoload
(dolist (hook '(alchemist-mode-hook))
  (add-hook hook 'alchemist-test-enable-mode))

(provide 'alchemist-test-mode)

;;; alchemist-test-mode.el ends here
alchemist-20180312.1304/alchemist-help.el0000664000175000017500000002703014133447044016232 0ustar  kimrkimr;;; alchemist-help.el --- Functionality for Elixir documentation lookup -*- lexical-binding: t -*-

;; Copyright © 2014-2017 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:

;; Functionality for Elixir documentation lookup.

;;; Code:

(require 'dash)
(require 's)
(require 'ansi-color)
(require 'alchemist-utils)
(require 'alchemist-project)
(require 'alchemist-server)
(require 'alchemist-scope)
(require 'alchemist-goto)

(defgroup alchemist-help nil
  "Functionality for Elixir documentation lookup."
  :prefix "alchemist-help-"
  :group 'alchemist)

(defcustom alchemist-help-buffer-name "*alchemist help*"
  "Name of the Elixir help buffer."
  :type 'string
  :group 'alchemist-help)

(defvar alchemist-help-search-history '()
  "Storage for the search history.")

(defvar alchemist-help-current-search-text '()
  "Stores the current search.")

(defvar alchemist-help-filter-output nil)

(defface alchemist-help-key-face
  '((t (:inherit font-lock-variable-name-face :bold t :foreground "red")))
  "Face for the letter keys in the summary."
  :group 'alchemist-help)

(defun alchemist-help-lookup-doc (search)
  "Lookup Elixir documentation for SEARCH."
  (setq alchemist-help-current-search-text search)
  (setq alchemist-help-filter-output nil)
  (if (not (s-blank? search))
      (alchemist-server-complete-candidates
       (alchemist-help--completion-server-arguments search)
       #'alchemist-help-complete-filter-output)
    (message "No documentation for [%s] found." search)))

(defun alchemist-help-no-doc-available-p (string)
  "Return non-nil if STRING contains Elixir no documentation message."
  (or (string-match-p "No documentation for" string)
      (string-match-p "Could not load module" string)
      (string-match-p "it does not have Elixir-style docs" string)
      (s-blank? string)))

(defun alchemist-help-store-search-in-history ()
  "Store the last `alchemist-help-current-search-text' in `alchemist-help-search-history'."
  (unless (memq 'alchemist-help-current-search-text alchemist-help-search-history)
    (add-to-list 'alchemist-help-search-history alchemist-help-current-search-text)))

(defun alchemist-help-display-doc (content)
  "Initialize the `alchemist-help-buffer-name' and insert CONTENT."
  (let ((default-directory (alchemist-project-root-or-default-dir))
        (buffer (get-buffer-create alchemist-help-buffer-name)))
    (cond
     ((alchemist-help-no-doc-available-p content)
      (message (format "No documentation for [%s] found."
                       alchemist-help-current-search-text)))
     (t
      (alchemist-help-store-search-in-history)
      (with-current-buffer buffer
        (let ((inhibit-read-only t))
          (goto-char (point-min))
          (erase-buffer)
          (insert content)
          (goto-char (point-min))
          (ansi-color-apply-on-region (point-min) (point-max))
          (alchemist-help-minor-mode)))
      (pop-to-buffer buffer)))))

(defun alchemist-help--search-at-point ()
  "Search through `alchemist-help' with the expression under the cursor"
  (let* ((expr (alchemist-scope-expression)))
    (alchemist-help-lookup-doc (alchemist-help--prepare-search-expr expr))))

(defun alchemist-help--search-marked-region (begin end)
  "Run `alchemist-help' with the marked region.
Argument BEGIN where the mark starts.
Argument END where the mark ends."
  (let ((expr (buffer-substring-no-properties begin end)))
    (alchemist-help-lookup-doc (alchemist-help--prepare-search-expr expr))))

(defun alchemist-help--prepare-search-expr (expr)
  (let* ((module (alchemist-scope-extract-module expr))
         (module (alchemist-scope-alias-full-path module))
         (module (if module module ""))
         (function (alchemist-scope-extract-function expr))
         (function (if function function ""))
         (expr (cond
                ((and (not (s-blank? module))
                      (not (s-blank? function)))
                 (format "%s.%s" module function))
                ((not (s-blank? module))
                 module)
                (t
                 expr))))
    expr))

(defun alchemist-help--elixir-modules-to-list (str)
  (let* ((str (replace-regexp-in-string "^Elixir\\." "" str))
         (modules (split-string str))
         (modules (delete nil modules))
         (modules (cl-sort modules 'string-lessp :key 'downcase))
         (modules (-distinct modules)))
    modules))

(defun alchemist-help-minor-mode-key-binding-summary ()
  (interactive)
  (message
   (concat "[" (propertize "q" 'face 'alchemist-help-key-face)
           "]-quit ["
           (propertize "e" 'face 'alchemist-help-key-face)
           "]-search-at-point ["
           (propertize "m" 'face 'alchemist-help-key-face)
           "]-search-module ["
           (propertize "s" 'face 'alchemist-help-key-face)
           "]-search ["
           (propertize "h" 'face 'alchemist-help-key-face)
           "]-history ["
           (propertize "?" 'face 'alchemist-help-key-face)
           "]-keys")))

(defun alchemist-help--server-arguments (args)
  (if (and (not (equal major-mode 'alchemist-iex-mode))
           (not (bound-and-true-p alchemist-help-minor-mode)))
      (let* ((modules (alchemist-utils-prepare-modules-for-elixir
                       (alchemist-scope-all-modules))))
        (format "{ \"%s\", [ context: Elixir, imports: %s, aliases: [] ] }" args modules))
    (format "{ \"%s\", [ context: Elixir, imports: [], aliases: [] ] }" args)))

(defun alchemist-help--completion-server-arguments (args)
  "Build informations about the current context."
  (if (and (not (equal major-mode 'alchemist-iex-mode))
           (not (bound-and-true-p alchemist-help-minor-mode)))
      (let* ((modules (alchemist-utils-prepare-modules-for-elixir
                       (alchemist-scope-all-modules)))
             (aliases (alchemist-utils-prepare-aliases-for-elixir
                       (alchemist-scope-aliases))))
        (format "{ \"%s\", [ context: Elixir, imports: %s, aliases: %s ] }" args modules aliases))
    (format "{ \"%s\", [ context: Elixir, imports: [], aliases: [] ] }" args)))

(defun alchemist-help-complete-filter-output (_process output)
  (with-local-quit
    (setq alchemist-help-filter-output (cons output alchemist-help-filter-output))
    (if (alchemist-server-contains-end-marker-p output)
        (let* ((string (alchemist-server-prepare-filter-output alchemist-help-filter-output))
               (candidates (alchemist-complete--output-to-list
                            (ansi-color-filter-apply string)))
               (candidates (if (= (length candidates) 2)
                               nil
                             candidates)))
          (setq alchemist-help-filter-output nil)
          (if candidates
              (let* ((search (alchemist-complete--completing-prompt alchemist-help-current-search-text candidates)))
                (setq alchemist-help-current-search-text search)
                (alchemist-server-help (alchemist-help--server-arguments search) #'alchemist-help-filter-output))
            (alchemist-server-help (alchemist-help--server-arguments alchemist-help-current-search-text) #'alchemist-help-filter-output))))))

(defun alchemist-help-filter-output (_process output)
  (setq alchemist-help-filter-output (cons output alchemist-help-filter-output))
  (if (alchemist-server-contains-end-marker-p output)
      (let ((string (alchemist-server-prepare-filter-output alchemist-help-filter-output)))
        (alchemist-help-display-doc string)
        (setq alchemist-help-current-search-text nil)
        (setq alchemist-help-filter-output nil))))

(defun alchemist-help-modules-filter (_process output)
  (with-local-quit
    (setq alchemist-help-filter-output (cons output alchemist-help-filter-output))
    (if (alchemist-server-contains-end-marker-p output)
        (let* ((output (alchemist-server-prepare-filter-output alchemist-help-filter-output))
               (modules (alchemist-help--elixir-modules-to-list output))
               (search (completing-read
                        "Elixir help: "
                        modules
                        nil
                        nil
                        nil))
               (module (alchemist-scope-extract-module search))
               (function (alchemist-scope-extract-function search))
               (search (cond
                        ((and module function)
                         search)
                        ((and module
                              (not (string-match-p "[\/0-9]+$" module)))
                         (concat module "."))
                        (t
                         search))))
          (alchemist-help-lookup-doc (alchemist-utils-remove-dot-at-the-end search))))))

;; Public functions

(defun alchemist-help-search-at-point ()
  "Search through `alchemist-help' with the expression under the cursor.

If the buffer local variable `mark-active' is non-nil,
the actively marked region will be used for passing to `alchemist-help'."
  (interactive)
  (if mark-active
      (alchemist-help--search-marked-region (region-beginning) (region-end))
      (alchemist-help--search-at-point)))

(defun alchemist-help-module ()
  "Load Elixir documentation for the module of the most recent SEARCH.

This is helpful to jump from the documentation of, say, the String.split/1
function to the documetation of the String module."
  (interactive)
  (let* ((current-search (car alchemist-help-search-history))
         (module (alchemist-scope-extract-module current-search))
         (module (alchemist-scope-alias-full-path module)))

    (if module
        (alchemist-help-lookup-doc (alchemist-help--prepare-search-expr module))
      (message "No module found"))))

(defvar alchemist-help-minor-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "q") #'quit-window)
    (define-key map (kbd "e") #'alchemist-help-search-at-point)
    (define-key map (kbd "m") #'alchemist-help-module)
    (define-key map (kbd "s") #'alchemist-help)
    (define-key map (kbd "h") #'alchemist-help-history)
    (define-key map (kbd "M-.") #'alchemist-goto-definition-at-point)
    (define-key map (kbd "?") #'alchemist-help-minor-mode-key-binding-summary)
    map)
  "Keymap for `alchemist-help-minor-mode'.")

(define-minor-mode alchemist-help-minor-mode
  "Minor mode for displaying elixir help."
  :group 'alchemist-help
  :keymap alchemist-help-minor-mode-map
  (cond (alchemist-help-minor-mode
         (setq buffer-read-only t))
        (t
         (setq buffer-read-only nil))))

(defun alchemist-help ()
  "Load Elixir documentation for SEARCH."
  (interactive)
  (setq alchemist-help-filter-output nil)
  (alchemist-server-info "{ :type, :modules }" #'alchemist-help-modules-filter))

(defun alchemist-help-history (search)
  "Load Elixir from the documentation history for SEARCH."
  (interactive
   (list
    (completing-read "Elixir help history: " alchemist-help-search-history nil nil "")))
  (alchemist-help-lookup-doc search))

(provide 'alchemist-help)

;;; alchemist-help.el ends here
alchemist-20180312.1304/alchemist-file.el0000664000175000017500000000377714133447044016235 0ustar  kimrkimr;;; alchemist-file.el --- Functionality to work with directory content

;; Copyright © 2014-2017 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:

;; Functionality to work with directory content.

;;; Code:

(defgroup alchemist-file nil
  "Functionality to work with directory content."
  :prefix "alchemist-file-"
  :group 'alchemist)

(defun alchemist-file-find-files (root directory)
  "Open DIRECTORY inside ROOT and prompt for a file."
  (let* ((files (alchemist-file-read-dir root directory))
         (root-name (car (cdr (reverse (split-string root "/")))))
         (file (completing-read (format "[%s] %s: " root-name directory) files)))
    (find-file (expand-file-name file root))))

(defun alchemist-file-read-dir (root directory)
  "Return all files in DIRECTORY and use ROOT as `default-directory'."
  (let ((default-directory root))
    (-map (lambda (file) (file-relative-name file root))
          (alchemist-file--files-from directory))))

(defun alchemist-file--files-from (directory)
  (--mapcat
   (if (file-directory-p it)
       (unless (or (equal (file-relative-name it directory) "..")
                   (equal (file-relative-name it directory) "."))
         (alchemist-file--files-from it))
     (list it))
   (directory-files directory t)))

(provide 'alchemist-file)

;;; alchemist-file.el ends here