Clean up more JS references.

Author: josteink

README.org

@@ -1,4 +1,4 @@
-* ts-comint.el (v0.0.5)
+* ts-comint.el (v0.0.1)
 Run a TypeScript interpreter in an inferior process window
 
 This repo is directly forked from
@@ -36,9 +36,9 @@ Insert below code to "~/.emacs.d/init.el",
 #+END_SRC
 
 * Usage
-After installation, do `M-x run-ts` to create a comint buffer with the JavaScript interpreter.
+After installation, do `M-x run-ts` to create a comint buffer with the Typescript interpreter.
 
-You can add the following couple of lines to your .emacs to take advantage of cool key bindings for sending things to the javascript interpreter inside of Steve Yegge's most excellent js2-mode.
+You can add the following couple of lines to your .emacs to take advantage of cool key bindings for sending things to the Typescript interpreter inside of Steve Yegge's most excellent js2-mode.
 
 #+BEGIN_SRC elisp
 (add-hook 'typescript-mode-hook

ts-comint.el

@@ -2,11 +2,11 @@
 
 ;;; Copyright (C) 2008 Paul Huff
 ;;; Copyright (C) 2015 Stefano Mazzucco
+;;; Copyright (C) 2016 Jostein Kjønigsen
 
 ;;; Author: Paul Huff <paul.huff@gmail.com>, Stefano Mazzucco <MY FIRST NAME - AT - CURSO - DOT - RE>
-;;; Maintainer: Chen Bin <chenbin.sh AT gmail DOT com>
-;;; Created: 15 Feb 2014
-;;; Version: 0.0.5
+;;; Created: 28 September 2016
+;;; Version: 0.0.1
 ;;; URL: https://github.com/josteink/ts-comint
 ;;; Package-Requires: ()
 ;;; Keywords: javascript, node, inferior-mode, convenience
@@ -37,8 +37,8 @@
 ;;; Commentary:
 
 ;; ts-comint.el is a comint mode for Emacs which allows you to run a
-;; compatible javascript repl like Node.js/Spidermonkey/Rhino inside Emacs.
-;; It also defines a few functions for sending javascript input to it
+;; compatible typescript repl like Tsun inside Emacs.
+;; It also defines a few functions for sending typescript input to it
 ;; quickly.
 
 ;; Usage:
@@ -48,19 +48,11 @@
 ;;  Do: `M-x run-ts'
 ;;  Away you go.
 
-;;  If you have nvm, you can select the versions of node.js installed and run
-;;  them.  This is done thanks to nvm.el.
-;;  Please note nvm.el is optional. So you need *manually* install it.
-;;  To enable nvm support, run `ts-do-use-nvm'.
-;;  The first time you start the JS interpreter with run-ts, you will be asked
-;;  to select a version of node.js
-;;  If you want to change version of node js, run `ts-select-node-version'
-
 ;;  You can add  the following couple of lines to your .emacs to take advantage of
 ;;  cool keybindings for sending things to the javascript interpreter inside
 ;;  of Steve Yegge's most excellent js2-mode.
 ;;
-;;   (add-hook 'js2-mode-hook
+;;   (add-hook 'typescript-mode-hook
 ;;             (lambda ()
 ;;               (local-set-key (kbd "C-x C-e") 'ts-send-last-sexp)
 ;;               (local-set-key (kbd "C-M-x") 'ts-send-last-sexp-and-go)
@@ -81,35 +73,26 @@
   :group 'inferior-ts)
 
 (defcustom inferior-ts-program-arguments nil
-  "List of command line arguments to pass to the JavaScript interpreter."
+  "List of command line arguments to pass to the Typescript interpreter."
   :group 'inferior-ts)
 
 (defcustom inferior-ts-mode-hook nil
   "*Hook for customizing inferior-ts mode."
   :type 'hook
   :group 'inferior-ts)
 
+(defcustom inferior-ts-mode-ansi-color t
+  "Use ansi-colors for inferior Typescript mode."
+  :group 'inferior-ts)
 
 (defvar inferior-ts-buffer nil
-  "Name of the inferior JavaScript buffer.")
+  "Name of the inferior Typescript buffer.")
 
 (defvar ts-prompt-regexp "^\\(?:> \\)"
   "Prompt for `run-ts'.")
 
 
-(defun ts-list-nvm-versions (prompt)
-  "List all available node versions from nvm prompting the user with PROMPT.
-Return a string representing the node version."
-  (let ((candidates (sort (mapcar 'car (nvm--installed-versions)) 'string<)))
-    (completing-read prompt
-                     candidates nil t nil
-                     nil
-                     (car candidates))))
 ;;;###autoload
-(defun ts-do-use-nvm ()
-  "Enable nvm."
-  (setq ts-use-nvm t))
-
 (defun ts--is-nodejs ()
   (string= "node"
            (substring-no-properties inferior-ts-program-command -4 nil)))
@@ -123,8 +106,8 @@ Return a string representing the node version."
 
 ;;;###autoload
 (defun run-ts (cmd &optional dont-switch-p)
-  "Run an inferior Javascript process, input and output via buffer `*js*'.
-If there is a process already running in `*js*', switch to that buffer.
+  "Run an inferior Typescript process, input and output via buffer `*ts*'.
+If there is a process already running in `*ts*', switch to that buffer.
 With argument, allows you to edit the command line (default is value
 of `inferior-ts-program-command').
 Runs the hook `inferior-ts-mode-hook' \(after the `comint-mode-hook'
@@ -144,26 +127,41 @@ is run).
       (setq inferior-ts-program-arguments (split-string cmd))
       (setq inferior-ts-program-command (pop inferior-ts-program-arguments)))))
 
-  (if (not (comint-check-proc "*js*"))
+  (if (not (comint-check-proc "*ts*"))
       (with-current-buffer
-          (apply 'make-comint "js" inferior-ts-program-command
+          (apply 'make-comint "ts" inferior-ts-program-command
                  nil inferior-ts-program-arguments)
         (inferior-ts-mode)))
-  (setq inferior-ts-buffer "*js*")
+  (setq inferior-ts-buffer "*ts*")
   (if (not dont-switch-p)
-      (pop-to-buffer "*js*")))
+      (pop-to-buffer "*ts*"))
+
+  ;; apply terminal preferences
+  (if inferior-ts-mode-ansi-color
+      (progn
+        ;; based on
+        ;; http://stackoverflow.com/questions/13862471/using-node-ts-with-ts-comint-in-emacs
+
+        ;; We like nice colors
+        (ansi-color-for-comint-mode-on)
+        ;; Deal with some prompt nonsense
+        (add-to-list
+         'comint-preoutput-filter-functions
+         (lambda (output)
+           (replace-regexp-in-string "\033\\[[0-9]+[GKJ]" "" output))))
+    (setenv "NODE_NO_READLINE" "1")))
 
 ;;;###autoload
 (defun ts-send-region (start end)
-  "Send the current region to the inferior Javascript process."
+  "Send the current region to the inferior Typescript process."
   (interactive "r")
   (run-ts inferior-ts-program-command t)
   (comint-send-region inferior-ts-buffer start end)
   (comint-send-string inferior-ts-buffer "\n"))
 
 ;;;###autoload
 (defun ts-send-region-and-go (start end)
-  "Send the current region to the inferior Javascript process."
+  "Send the current region to the inferior Typescript process."
   (interactive "r")
   (run-ts inferior-ts-program-command t)
   (comint-send-region inferior-ts-buffer start end)
@@ -172,7 +170,7 @@ is run).
 
 ;;;###autoload
 (defun ts-send-last-sexp-and-go ()
-  "Send the previous sexp to the inferior Js process."
+  "Send the previous sexp to the inferior Typescript process."
   (interactive)
   (ts-send-region-and-go
    (save-excursion
@@ -183,7 +181,7 @@ is run).
 
 ;;;###autoload
 (defun ts-send-last-sexp ()
-  "Send the previous sexp to the inferior Javascript process."
+  "Send the previous sexp to the inferior Typescript process."
   (interactive)
   (ts-send-region
    (save-excursion
@@ -194,14 +192,14 @@ is run).
 
 ;;;###autoload
 (defun ts-send-buffer ()
-  "Send the buffer to the inferior Javascript process."
+  "Send the buffer to the inferior Typescript process."
   (interactive)
   (ts-send-region (point-min) (point-max)))
 
 
 ;;;###autoload
 (defun ts-send-buffer-and-go ()
-  "Send the buffer to the inferior Javascript process."
+  "Send the buffer to the inferior Typescript process."
   (interactive)
   (ts-send-region-and-go (point-min) (point-max)))
 
@@ -241,7 +239,7 @@ With argument, position cursor at end of buffer."
     m))
 
 ;;;###autoload
-(define-derived-mode inferior-ts-mode comint-mode "Inferior Javascript"
+(define-derived-mode inferior-ts-mode comint-mode "Inferior Typescript"
   "Major mode for interacting with an inferior javascript process.
 
 The following commands are available:
@@ -252,25 +250,13 @@ A typescript process can be fired up with M-x run-ts.
 Customization: Entry to this mode runs the hooks on comint-mode-hook and
 inferior-ts-mode-hook (in that order).
 
-You can send text to the inferior Javascript process from other buffers containing
-Javascript source.
-    switch-to-js switches the current buffer to the Javascript process buffer.
-    ts-send-region sends the current region to the Javascript process.
+You can send text to the inferior Typescript process from other buffers containing
+Typescript source.
+    switch-to-js switches the current buffer to the Typescript process buffer.
+    ts-send-region sends the current region to the Typescript process.
 "
   :group 'inferior-ts
   (use-local-map inferior-ts-mode-map))
 
-;; based on
-;; http://stackoverflow.com/questions/13862471/using-node-ts-with-ts-comint-in-emacs
-(setq inferior-ts-mode-hook
-      (lambda ()
-        ;; We like nice colors
-        (ansi-color-for-comint-mode-on)
-        ;; Deal with some prompt nonsense
-        (add-to-list
-         'comint-preoutput-filter-functions
-         (lambda (output)
-           (replace-regexp-in-string "\033\\[[0-9]+[GKJ]" "" output)))))
-
 (provide 'ts-comint)
 ;;; ts-comint.el ends here