nico
/
Indium


								;;; indium-repl.el --- JavaScript REPL connected to a browser tab  -*- lexical-binding: t; -*-


								;; Copyright (C) 2016-2018  Nicolas Petton


								;; Author: Nicolas Petton <nicolas@petton.fr>

								;; Keywords: convenience, tools, javascript


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


								;; REPL interactions with a browser connection.


								;;; Code:


								(require 'indium-render)

								(require 'indium-faces)

								(require 'indium-client)

								(require 'indium-debugger)


								(require 'company)

								(require 'easymenu)

								(require 'map)

								(require 'js)


								(require 'subr-x)

								(require 'ansi-color)


								(declare-function indium-inspector-inspect "indium-inspector.el")

								(declare-function indium-maybe-quit "indium-interaction.el")


								(defgroup indium-repl nil

								  "Interaction with the REPL."

								  :prefix "indium-repl-"

								  :group 'indium)


								(defvar indium-repl-evaluate-hook nil

								  "Hook run when input is evaluated in the repl.")


								(defvar indium-repl-switch-from-buffer nil

								  "The buffer from which repl was activated last time.")


								(defvar indium-repl-history nil "History of the REPL inputs.")

								(make-variable-buffer-local 'indium-repl-history)

								(defvar indium-repl-history-position -1 "Position in the REPL history.")

								(make-variable-buffer-local 'indium-repl-history-position)


								(defvar-local indium-repl-input-start-marker nil)

								(defvar-local indium-repl-output-start-marker nil)

								(defvar-local indium-repl-output-end-marker nil)


								(defmacro indium-save-marker (marker &rest body)

								  "Save MARKER and execute BODY."

								  (declare (indent 1) (debug t))

								  (let ((pos (make-symbol "pos")))

								    `(let ((,pos (marker-position ,marker)))

								       (prog1 (progn . ,body)

								         (set-marker ,marker ,pos)))))


								(defun indium-repl-setup ()

								  "Create and switch to the REPL buffer."

								  (switch-to-buffer (indium-repl-get-buffer-create)))


								(defun indium-repl-get-buffer-create ()

								  "Return a new REPL buffer."

								  (let* ((buf (get-buffer-create (indium-repl-buffer-name))))

								    (indium-repl-setup-buffer buf)

								    buf))


								(defun indium-repl-get-buffer ()

								  "Return the REPL buffer, or nil."

								  (get-buffer (indium-repl-buffer-name)))


								(defun indium-repl-buffer-name ()

								  "Return the name of the REPL buffer."

								  "*JS REPL*")


								(defun indium-repl-setup-buffer (buffer)

								  "Setup the REPL BUFFER."

								  (with-current-buffer buffer

								    (unless (eq major-mode 'indium-repl-mode)

								      (indium-repl-mode)

								      (indium-repl-setup-markers)

								      (indium-repl-mark-output-start)

								      (indium-repl-insert-prompt)

								      (indium-repl-mark-input-start)

								      (indium-repl-emit-console-message

								       `((result . ,(indium-remote-object-create

										     :description (indium-repl--welcome-message))))))))


								(defun indium-repl--welcome-message ()

								  "Return the welcome message displayed in new REPL buffers."

								  (substitute-command-keys

								   "/* Welcome to Indium!


								Getting started:


								- Press <\\[indium-repl-return]> on links to open an inspector

								- Press <\\[indium-repl-previous-input]> and <\\[indium-repl-next-input]> to navigate in the history

								- Use <\\[indium-scratch]> to open a scratch buffer for JS evaluation

								- Press <\\[describe-mode]> to see a list of available keybindings

								- Press <\\[indium-repl-clear-output]> to clear the output


								To disconnect from the JavaScript process, press <\\[indium-quit]>.

								Doing this will also close all inspectors and debugger buffers

								connected to the process.


								*/"))


								(defun indium-repl-setup-markers ()

								  "Setup the initial markers for the current REPL buffer."

								  (dolist (marker '(indium-repl-output-start-marker

								                    indium-repl-output-end-marker

								                    indium-repl-input-start-marker))

								    (set marker (make-marker))

								    (set-marker (symbol-value marker) (point))))


								(defun indium-repl-mark-output-start ()

								  "Mark the output start."

								  (set-marker indium-repl-output-start-marker (point))

								  (set-marker indium-repl-output-end-marker (point)))


								(defun indium-repl-mark-input-start ()

								  "Mark the input start."

								  (set-marker indium-repl-input-start-marker (point)))


								(defun indium-repl-insert-prompt ()

								  "Insert the prompt in the REPL buffer."

								  (goto-char indium-repl-input-start-marker)

								  (indium-save-marker indium-repl-output-start-marker

								    (indium-save-marker indium-repl-output-end-marker

								      (unless (bolp)

								        (insert-before-markers "\n"))

								      (insert-before-markers "js> ")

								      (let ((beg (save-excursion

								                   (beginning-of-line)

								                   (point)))

								            (end (point)))

								        (set-text-properties beg end

								                             '(font-lock-face indium-repl-prompt-face

								                                              read-only t

								                                              intangible t

								                                              field indium-repl-prompt

								                                              rear-nonsticky (read-only font-lock-face intangible field)))))))


								(defun indium-repl-return ()

								  "Depending on the position of point, jump to a reference of evaluate the input."

								  (interactive)

								  (cond

								   ((get-text-property (point) 'indium-reference) (indium-follow-link))

								   ((get-text-property (point) 'indium-action) (indium-perform-action))

								   ((indium-repl--in-input-area-p) (indium-repl-evaluate (indium-repl--input-content)))

								   (t (error "No input or action at point"))))


								(defun indium-repl-inspect ()

								  "Inspect the result of the evaluation of the input at point."

								  (interactive)

								  (indium-client-evaluate (indium-repl--input-content)

								                          indium-debugger-current-frame

								                          (lambda (result)

								                            (indium-inspector-inspect result))))


								(defun indium-repl--input-content ()

								  "Return the content of the current input."

								  (buffer-substring-no-properties indium-repl-input-start-marker (point-max)))


								(defun indium-repl--in-input-area-p ()

								  "Return t if in input area."

								  (<= indium-repl-input-start-marker (point)))


								(defun indium-repl-evaluate (string)

								  "Evaluate STRING in the browser tab and emit the output."

								  (push string indium-repl-history)

								  (indium-client-evaluate string indium-debugger-current-frame #'indium-repl-emit-value)

								  ;; move the output markers so that output is put after the current prompt

								  (save-excursion

								    (goto-char (point-max))

								    (set-marker indium-repl-output-start-marker (point))

								    (set-marker indium-repl-output-end-marker (point))))


								(defun indium-repl-emit-value (value)

								  "Emit a string representation of the remote object VALUE."

								  (with-current-buffer (indium-repl-get-buffer)

								    (save-excursion

								      (goto-char (point-max))

								      (insert-before-markers "\n")

								      (set-marker indium-repl-output-start-marker (point))

								      (indium-render-remote-object value)

								      (insert "\n")

								      (indium-repl-mark-input-start)

								      (set-marker indium-repl-output-end-marker (point)))

								    (indium-repl-insert-prompt)

								    (run-hooks 'indium-repl-evaluate-hook)))


								(defun indium-repl-emit-console-message (message &optional error)

								  "Emit a console MESSAGE.

								When ERROR is non-nil, display MESSAGE as an error.


								MESSAGE is a map (alist/hash-table) with the following keys:

								  type		type of message

								  url		url of the message origin

								  line		line number in the resource that generated this message

								  result 	object to be logged


								MESSAGE must contain `result'.  Other fields are

								optional."

								  (with-current-buffer (indium-repl-get-buffer)

								    (let-alist message

								      (when (string= .type 'error)

									(setq error t)))

								    (save-excursion

								      (goto-char indium-repl-output-end-marker)

								      (set-marker indium-repl-output-start-marker (point))

								      (insert "\n")

								      (when error

								        (indium-repl--emit-logging-error))

								      (indium-repl--emit-message message)

								      (set-marker indium-repl-output-end-marker (point))

								      (unless (eolp)

								        (insert "\n")))))


								(defun indium-repl--emit-message (message)

								  "Emit the value of console MESSAGE."

								  (let-alist message

								    (indium-render-remote-object .result)

								    (indium-repl--emit-message-url-line .url .line)))


								(defun indium-repl--emit-logging-error ()

								  "Emit a red \"Error\" label."

								  (insert

								   (ansi-color-apply

								    (propertize "Error:"

								                'font-lock-face 'indium-repl-error-face

								                'rear-nonsticky '(font-lock-face)))

								   " "))


								(defun indium-repl--emit-message-url-line (url line)

								  "Emit the URL and LINE for a message."

								  (unless (seq-empty-p url)

								    (insert "\nFrom "

								            (propertize (if line

								                            (format "%s:%s" url line)

								                          url)

								                        'font-lock-face 'indium-link-face

								                        'indium-action (lambda ()

								                                         (if (file-regular-p url)

								                                             (find-file url)

								                                           (browse-url url)))

								                        'rear-nonsticky '(font-lock-face indium-action)))))


								(defun indium-repl-next-input ()

								  "Insert the content of the next input in the history."

								  (interactive)

								  (indium-repl--history-replace 'forward))


								(defun indium-repl-previous-input ()

								  "Insert the content of the previous input in the history."

								  (interactive)

								  (indium-repl--history-replace 'backward))


								(defun indium-repl--history-replace (direction)

								  "Replace the current input with one the next one in DIRECTION.

								DIRECTION is `forward' or `backard' (in the history list)."

								  (let* ((history (seq-reverse indium-repl-history))

								         (search-in-progress (or (eq last-command 'indium-repl-previous-input)

								                                 (eq last-command 'indium-repl-next-input)))

								         (step (pcase direction

								                 (`forward 1)

								                 (`backward -1)))

								         (pos (or (and search-in-progress (+ indium-repl-history-position step))

								                  (1- (seq-length history)))))

								    (unless (>= pos 0)

								      (user-error "Beginning of history"))

								    (unless (< pos (seq-length history))

								      (user-error "End of history"))

								    (setq indium-repl-history-position pos)

								    (indium-repl--replace-input (seq-elt history pos))))


								(defun indium-repl--replace-input (input)

								  "Replace the current input with INPUT."

								  (goto-char (point-max))

								  (delete-region indium-repl-input-start-marker (point))

								  (insert input))


								(defun indium-repl-clear-output ()

								  "Clear all output contents of the current buffer."

								  (interactive)

								  (let ((inhibit-read-only t))

								    (save-excursion

								      (goto-char (point-min))

								      (delete-region (point) indium-repl-output-end-marker))))


								(defun indium-repl-pop-buffer ()

								  "Switch to the buffer from which repl was opened buffer if any."

								  (interactive)

								  (when indium-repl-switch-from-buffer

								    (pop-to-buffer indium-repl-switch-from-buffer t)))


								(defun company-indium-repl (command &optional arg &rest _args)

								  "Indium REPL backend for company-mode.

								See `company-backends' for more info about COMMAND and ARG."

								  (interactive (list 'interactive))

								  (cl-case command

								    (interactive (company-begin-backend 'company-indium-repl))

								    (prefix (indium-repl-company-prefix))

								    (ignore-case t)

								    (sorted t)

								    (candidates (cons :async

								                      (lambda (callback)

								                        (indium-repl-get-completions arg callback))))))


								(defun indium-repl-get-completions (prefix callback)

								  "Get the completion list matching PREFIX.

								Evaluate CALLBACK with the completion candidates."

								  (let* ((input (buffer-substring-no-properties

								                 (let ((bol (point-at-bol))

								                       (prev-delimiter (1+ (save-excursion

								                                             (re-search-backward "[([:space:]]" nil t)))))

								                   (if prev-delimiter

								                       (max bol prev-delimiter)

								                     bol))

								                 (point)))

									 (expression  (if (string-match-p "\\." input)

											  (replace-regexp-in-string "\\.[^\\.]*$" "" input)

											"this")))

								    (indium-client-get-completion

								     expression

								     indium-debugger-current-frame

								     (lambda (candidates)

								       (funcall callback

										(seq-filter (lambda (candidate)

								                              (string-prefix-p prefix candidate))

								                            candidates))))))


								(defun indium-repl--complete-or-indent ()

								  "Complete or indent at point."

								  (interactive)

								  (if (company-manual-begin)

								      (company-complete-common)

								    (indent-according-to-mode)))


								(defun indium-repl-company-prefix ()

								  "Prefix for company."

								  (and (or (eq major-mode 'indium-repl-mode)

								           (bound-and-true-p indium-interaction-mode))

								       (or (company-grab-symbol-cons "\\." 1)

								           'stop)))


								(defvar indium-repl-mode-hook nil

								  "Hook executed when entering `indium-repl-mode'.")


								(defvar indium-repl-mode-map

								  (let ((map (make-sparse-keymap)))

								    (define-key map [return] #'indium-repl-return)

								    (define-key map "\C-m" #'indium-repl-return)

								    (define-key map (kbd "TAB") #'indium-repl--complete-or-indent)

								    (define-key map [mouse-1] #'indium-follow-link)

								    (define-key map (kbd "C-<return>") #'newline)

								    (define-key map (kbd "C-c M-i") #'indium-repl-inspect)

								    (define-key map (kbd "C-c C-o") #'indium-repl-clear-output)

								    (define-key map (kbd "C-c C-z") #'indium-repl-pop-buffer)

								    (define-key map (kbd "C-c C-q") #'indium-maybe-quit)

								    (define-key map (kbd "M-p") #'indium-repl-previous-input)

								    (define-key map (kbd "M-n") #'indium-repl-next-input)

								    (define-key map (kbd "C-<up>") #'indium-repl-previous-input)

								    (define-key map (kbd "C-<down>") #'indium-repl-next-input)

								    (easy-menu-define indium-repl-mode-menu map

								      "Menu for Indium REPL"

								      '("Indium REPL"

								        ["Clear output" indium-repl-clear-output]

								        ["Inspect" indium-repl-inspect]

								        "--"

								        ["Switch to source buffer" indium-repl-pop-buffer]

								        "--"

								        ["Quit" indium-maybe-quit]))

								    map))


								(define-derived-mode indium-repl-mode fundamental-mode "JS-REPL"

								  "Major mode for indium REPL interactions.


								\\{indium-repl-mode-map}"

								  (font-lock-add-keywords nil '(indium-repl--fontify-output))

								  (setq-local company-backends '(company-indium-repl))

								  (company-mode 1))


								(defun indium-repl--fontify-output (&rest _)

								  "Fontify JS code output."

								  (let* ((start indium-repl-input-start-marker)

									 (end (point-max))

									 (repl-buffer (current-buffer))

									 (string (buffer-substring-no-properties start end)))

								    (with-current-buffer

									(get-buffer-create " indium-fontification ")

								      (let ((inhibit-modification-hooks nil))

									(js-mode)

									(erase-buffer)

									(insert string " ")

									(font-lock-ensure)

									(let ((pos (point-min)) next)

									  (while (setq next (next-property-change pos))

									    ;; Handle additional properties from font-lock, so as to

									    ;; preserve, e.g., composition.

									    (dolist (prop (cons 'face font-lock-extra-managed-props))

									      (let ((new-prop (get-text-property pos prop)))

										(put-text-property

										 (+ start (1- pos)) (1- (+ start next)) prop new-prop

										 repl-buffer)))

									    (setq pos next)))))))


								(add-hook 'indium-client-connected-hook #'indium-repl-setup)

								(add-hook 'indium-client-log-hook #'indium-repl-emit-console-message)


								(provide 'indium-repl)

								;;; indium-repl.el ends here