[nongnu] elpa/parseclj 61513d2c99 164/185: Merge pull request #27 from clojure-emacs/shebang-and-symbolic-values

[ELPA Syncer]

branch: elpa/parseclj
commit 61513d2c9939e3b423b2270c9652d0c6dae45c29
Merge: 1bb3800f8f 0d157d759b
Author: Arne Brasseur <arne.brasseur@gmail.com>
Commit: GitHub <noreply@github.com>

    Merge pull request #27 from clojure-emacs/shebang-and-symbolic-values
    
    Add support for shebang and symbolic values
---
 CHANGELOG.md              |  8 ++++-
 parseclj-lex.el           | 12 +++++--
 test/parseclj-lex-test.el | 36 ++++++++++++++++++--
 test/parseclj-test.el     | 83 ++++++++++++++++++++++++++++++++++++++---------
 4 files changed, 118 insertions(+), 21 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5489347902..7db45508be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,10 @@
-# Changelog
+# Unreleased
+
+- Added a `:read-one` option to read/parse a single form at a time
+- Support more reader dispatch macro forms: eval (`#=`), shebang (`#!`),
+  symbolic value (`##NaN`)
+
+## Added
 
 ## 0.2.0 (2020-10-12)
 
diff --git a/parseclj-lex.el b/parseclj-lex.el
index f3d445f48e..f7592dec0d 100644
--- a/parseclj-lex.el
+++ b/parseclj-lex.el
@@ -29,6 +29,7 @@
 
 (defvar parseclj-lex--leaf-tokens '(:whitespace
                                     :comment
+                                    :symbolic-value
                                     :number
                                     :nil
                                     :true
@@ -169,8 +170,8 @@ S goes through three transformations:
     (:symbol (intern (alist-get :form token)))
     (:keyword (intern (alist-get :form token)))
     (:string (parseclj-lex--string-value (alist-get :form token)))
-    (:character (parseclj-lex--character-value (alist-get :form token)))))
-
+    (:character (parseclj-lex--character-value (alist-get :form token)))
+    (:symbolic-value (intern (substring (alist-get :form token) 2)))))
 
 ;; Stream tokenization
 
@@ -515,6 +516,10 @@ See `parseclj-lex-token'."
            ((equal char ?=)
             (right-char)
             (parseclj-lex-token :eval "#=" pos))
+           ((equal char ?#)
+            (right-char)
+            (let ((sym (parseclj-lex-get-symbol-at-point (point))))
+              (parseclj-lex-token :symbolic-value (concat "##" sym) pos)))
            ((equal char ?\")
             (parseclj-lex-regex))
            ((equal char ?:)
@@ -529,6 +534,9 @@ See `parseclj-lex-token'."
            ((parseclj-lex-symbol-start-p char t)
             (right-char)
             (parseclj-lex-token :tag (concat "#" 
(parseclj-lex-get-symbol-at-point (1+ pos))) pos))
+           ((equal char ?!) ;; shebang
+            (left-char)
+            (parseclj-lex-comment))
            (t
             (while (not (or (parseclj-lex-at-whitespace-p)
                             (parseclj-lex-at-eof-p)))
diff --git a/test/parseclj-lex-test.el b/test/parseclj-lex-test.el
index 289fa72026..e528580ea8 100644
--- a/test/parseclj-lex-test.el
+++ b/test/parseclj-lex-test.el
@@ -21,11 +21,11 @@
 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 ;; Boston, MA 02110-1301, USA.
 
-;;; Commentary
+;;; Commentary:
 
 ;; Unit tests for the lexer
 
-;;; Code
+;;; Code:
 
 (require 'ert)
 (require 'parseclj-lex)
@@ -222,7 +222,37 @@
     (should (equal (parseclj-lex-next) (parseclj-lex-token :number "13" 18)))
     (should (equal (parseclj-lex-next) (parseclj-lex-token :whitespace " " 
20)))
     (should (equal (parseclj-lex-next) (parseclj-lex-token :number "14" 21)))
-    (should (equal (parseclj-lex-next) (parseclj-lex-token :rparen ")" 23)))))
+    (should (equal (parseclj-lex-next) (parseclj-lex-token :rparen ")" 23))))
+
+  (with-temp-buffer
+    (insert "#!/usr/bin/clojure")
+    (goto-char 1)
+    (should (equal (parseclj-lex-next) (parseclj-lex-token :comment 
"#!/usr/bin/clojure" 1))))
+
+  (with-temp-buffer
+    (insert "##-Inf ##Inf ##NaN")
+    (goto-char 1)
+    (should (equal
+             (list (parseclj-lex-next)
+                   (parseclj-lex-next)
+                   (parseclj-lex-next)
+                   (parseclj-lex-next)
+                   (parseclj-lex-next))
+             '(((:token-type . :symbolic-value)
+                (:form . "##-Inf")
+                (:pos . 1))
+               ((:token-type . :whitespace)
+                (:form . " ")
+                (:pos . 7))
+               ((:token-type . :symbolic-value)
+                (:form . "##Inf")
+                (:pos . 8))
+               ((:token-type . :whitespace)
+                (:form . " ")
+                (:pos . 13))
+               ((:token-type . :symbolic-value)
+                (:form . "##NaN")
+                (:pos . 14)))))))
 
 (ert-deftest parseclj-lex-test-at-number-p ()
   (dolist (str '("123" ".9" "+1" "0" "-456"))
diff --git a/test/parseclj-test.el b/test/parseclj-test.el
index a2c92e5fc2..3c4d690489 100644
--- a/test/parseclj-test.el
+++ b/test/parseclj-test.el
@@ -348,21 +348,74 @@
       top-value)))
 
 (ert-deftest parseclj---read-one-test ()
-  (equal (parseclj-parse-clojure "(+ 1 1) foo bar" :read-one t)
-         '((:node-type . :list)
-           (:position . 1)
-           (:children ((:node-type . :symbol)
-                       (:position . 2)
-                       (:form . "+")
-                       (:value . +))
-                      ((:node-type . :number)
-                       (:position . 4)
-                       (:form . "1")
-                       (:value . 1))
-                      ((:node-type . :number)
-                       (:position . 6)
-                       (:form . "1")
-                       (:value . 1))))))
+  (should (equal (parseclj-parse-clojure "(+ 1 1) foo bar" :read-one t)
+                 '((:node-type . :list)
+                   (:position . 1)
+                   (:children ((:node-type . :symbol)
+                               (:position . 2)
+                               (:form . "+")
+                               (:value . +))
+                              ((:node-type . :number)
+                               (:position . 4)
+                               (:form . "1")
+                               (:value . 1))
+                              ((:node-type . :number)
+                               (:position . 6)
+                               (:form . "1")
+                               (:value . 1)))))))
+
+(ert-deftest parseclj---shebang-test ()
+  (should
+   (equal (parseclj-parse-clojure "#!/bin/sh\n(+ 1 1)" :lexical-preservation t)
+          '((:node-type . :root)
+            (:lexical-preservation . t)
+            (:position . 1)
+            (:children ((:node-type . :comment)
+                        (:position . 1)
+                        (:form . "#!/bin/sh
+"))
+                       ((:node-type . :list)
+                        (:lexical-preservation . t)
+                        (:position . 11)
+                        (:children ((:node-type . :symbol)
+                                    (:position . 12)
+                                    (:form . "+")
+                                    (:value . +))
+                                   ((:node-type . :whitespace)
+                                    (:position . 13)
+                                    (:form . " "))
+                                   ((:node-type . :number)
+                                    (:position . 14)
+                                    (:form . "1")
+                                    (:value . 1))
+                                   ((:node-type . :whitespace)
+                                    (:position . 15)
+                                    (:form . " "))
+                                   ((:node-type . :number)
+                                    (:position . 16)
+                                    (:form . "1")
+                                    (:value . 1)))))))))
+
+
+(ert-deftest parseclj---symbolic-value-test ()
+  (should (equal (parseclj-parse-clojure "(* ##NaN 1)")
+                 '((:node-type . :root)
+                   (:position . 1)
+                   (:children ((:node-type . :list)
+                               (:position . 1)
+                               (:children ((:node-type . :symbol)
+                                           (:position . 2)
+                                           (:form . "*")
+                                           (:value . *))
+                                          ((:node-type . :symbolic-value)
+                                           (:position . 4)
+                                           (:form . "##NaN")
+                                           (:value . NaN))
+                                          ((:node-type . :number)
+                                           (:position . 10)
+                                           (:form . "1")
+                                           (:value . 1)))))))))
+
 
 (provide 'parseclj-test)