From bee75324e3287fe7e0240db1ff8a9360f4997123 Mon Sep 17 00:00:00 2001 From: Andreas Gerler Date: Sun, 26 Nov 2023 16:20:57 +0100 Subject: [PATCH] update parseedn Signed-off-by: Andreas Gerler --- elpa/parseedn-20190331.1058/parseedn-pkg.el | 2 - .../parseedn-autoloads.el | 8 +- elpa/parseedn-20220520.835/parseedn-pkg.el | 15 ++ .../parseedn.el | 168 +++++++++++++----- 4 files changed, 142 insertions(+), 51 deletions(-) delete mode 100644 elpa/parseedn-20190331.1058/parseedn-pkg.el rename elpa/{parseedn-20190331.1058 => parseedn-20220520.835}/parseedn-autoloads.el (64%) create mode 100644 elpa/parseedn-20220520.835/parseedn-pkg.el rename elpa/{parseedn-20190331.1058 => parseedn-20220520.835}/parseedn.el (51%) diff --git a/elpa/parseedn-20190331.1058/parseedn-pkg.el b/elpa/parseedn-20190331.1058/parseedn-pkg.el deleted file mode 100644 index 2f7d44f8..00000000 --- a/elpa/parseedn-20190331.1058/parseedn-pkg.el +++ /dev/null @@ -1,2 +0,0 @@ -;;; -*- no-byte-compile: t -*- -(define-package "parseedn" "20190331.1058" "Clojure/EDN parser" '((emacs "25") (a "0.1.0alpha4") (parseclj "0.1.0")) :commit "ddf824bc1df1585867cb7f27f2dd8ca8df760569" :keywords '("lisp" "clojure" "edn" "parser") :authors '(("Arne Brasseur" . "arne@arnebrasseur.net")) :maintainer '("Arne Brasseur" . "arne@arnebrasseur.net")) diff --git a/elpa/parseedn-20190331.1058/parseedn-autoloads.el b/elpa/parseedn-20220520.835/parseedn-autoloads.el similarity index 64% rename from elpa/parseedn-20190331.1058/parseedn-autoloads.el rename to elpa/parseedn-20220520.835/parseedn-autoloads.el index 9bdb12c3..511be462 100644 --- a/elpa/parseedn-20190331.1058/parseedn-autoloads.el +++ b/elpa/parseedn-20220520.835/parseedn-autoloads.el @@ -1,4 +1,4 @@ -;;; parseedn-autoloads.el --- automatically extracted autoloads +;;; parseedn-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*- ;; ;;; Code: @@ -9,7 +9,11 @@ ;;;### (autoloads nil "parseedn" "parseedn.el" (0 0 0 0)) ;;; Generated autoloads from parseedn.el -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "parseedn" '("parseedn-"))) +(register-definition-prefixes "parseedn" '("parseedn-")) + +;;;*** + +;;;### (autoloads nil nil ("parseedn-pkg.el") (0 0 0 0)) ;;;*** diff --git a/elpa/parseedn-20220520.835/parseedn-pkg.el b/elpa/parseedn-20220520.835/parseedn-pkg.el new file mode 100644 index 00000000..1bdee448 --- /dev/null +++ b/elpa/parseedn-20220520.835/parseedn-pkg.el @@ -0,0 +1,15 @@ +(define-package "parseedn" "20220520.835" "Clojure/EDN parser" + '((emacs "26") + (parseclj "1.1.0") + (map "2")) + :commit "a09686fbb9113b8b1b4f20c9e1dc0d6fea01a64f" :authors + '(("Arne Brasseur" . "arne@arnebrasseur.net")) + :maintainers + '(("Arne Brasseur" . "arne@arnebrasseur.net")) + :maintainer + '("Arne Brasseur" . "arne@arnebrasseur.net") + :keywords + '("lisp" "clojure" "edn" "parser")) +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/elpa/parseedn-20190331.1058/parseedn.el b/elpa/parseedn-20220520.835/parseedn.el similarity index 51% rename from elpa/parseedn-20190331.1058/parseedn.el rename to elpa/parseedn-20220520.835/parseedn.el index 45fd4f9e..eb367827 100644 --- a/elpa/parseedn-20190331.1058/parseedn.el +++ b/elpa/parseedn-20220520.835/parseedn.el @@ -1,12 +1,11 @@ ;;; parseedn.el --- Clojure/EDN parser -*- lexical-binding: t; -*- -;; Copyright (C) 2017-2018 Arne Brasseur +;; Copyright (C) 2017-2021 Arne Brasseur ;; Author: Arne Brasseur ;; Keywords: lisp clojure edn parser -;; Package-Version: 20190331.1058 -;; Package-Requires: ((emacs "25") (a "0.1.0alpha4") (parseclj "0.1.0")) -;; Version: 0.1.0 +;; Package-Requires: ((emacs "26") (parseclj "1.1.0") (map "2")) +;; Version: 1.1.0 ;; This file is not part of GNU Emacs. @@ -48,24 +47,41 @@ ;; Note that this is kind of broken, we don't correctly detect if \u or \o forms ;; don't have the right forms. -(require 'a) (require 'cl-lib) +(require 'map) (require 'parseclj-parser) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Reader (defvar parseedn-default-tag-readers - (a-list 'inst (lambda (s) - (cl-list* 'edn-inst (date-to-time s))) - 'uuid (lambda (s) - (list 'edn-uuid s))) + (list (cons 'inst (lambda (s) + (cl-list* 'edn-inst (date-to-time s)))) + (cons 'uuid (lambda (s) + (list 'edn-uuid s)))) "Default reader functions for handling tagged literals in EDN. These are the ones defined in the EDN spec, #inst and #uuid. It is not recommended you change this variable, as this globally changes the behavior of the EDN reader. Instead pass your own handlers as an optional argument to the reader functions.") +(defun parseedn-tagged-literal (tag form) + "Construct a data representation of a tagged literal from TAG and FORM." + (list 'edn-tagged-literal tag form)) + +(defvar parseedn-default-data-reader-fn nil + "The default tagged literal reader function. + +When no data reader is found for a tag and +`parseedn-default-data-reader-fn' is non-nil, it will be called +with two arguments, the tag and the value. If +`parseedn-default-data-reader-fn' is nil (the default), an +exception will be thrown for the unknown tag. + +The default data reader can also be provided via the tagged +reader options registered under the :default keyword when calling +the reader functions.") + (defun parseedn-reduce-leaf (stack token _options) "Put in the STACK an elisp value representing TOKEN. @@ -85,27 +101,31 @@ CHILDREN is a collection elisp values to be reduced into an elisp sequence. OPTIONS is an association list. See `parseclj-parse' for more information on available options." - (let ((tag-readers (a-merge parseedn-default-tag-readers (a-get options :tag-readers))) + (let ((tag-readers (parseclj-alist-merge parseedn-default-tag-readers (alist-get :tag-readers options))) (token-type (parseclj-lex-token-type opening-token))) (if (eq token-type :discard) stack (cons - (cl-case token-type - (:root children) - (:lparen children) - (:lbracket (apply #'vector children)) - (:set (list 'edn-set children)) - (:lbrace (let* ((kvs (seq-partition children 2)) - (hash-map (make-hash-table :test 'equal :size (length kvs)))) - (seq-do (lambda (pair) - (puthash (car pair) (cadr pair) hash-map)) - kvs) - hash-map)) - (:tag (let* ((tag (intern (substring (a-get opening-token :form) 1))) - (reader (a-get tag-readers tag :missing))) - (when (eq :missing reader) - (user-error "No reader for tag #%S in %S" tag (a-keys tag-readers))) - (funcall reader (car children))))) + (cond + ((eq :root token-type) children) + ((eq :lparen token-type) children) + ((eq :lbracket token-type) (apply #'vector children)) + ((eq :set token-type) (list 'edn-set children)) + ((eq :lbrace token-type) (let* ((kvs (seq-partition children 2)) + (hash-map (make-hash-table :test 'equal :size (length kvs)))) + (seq-do (lambda (pair) + (puthash (car pair) (cadr pair) hash-map)) + kvs) + hash-map)) + ((eq :tag token-type) (let* ((tag (intern (substring (alist-get :form opening-token) 1))) + (reader (alist-get tag tag-readers)) + (default-reader (alist-get :default tag-readers parseedn-default-data-reader-fn))) + (cond + ((functionp reader) + (funcall reader (car children))) + ((functionp default-reader) + (funcall default-reader tag (car children))) + (t (user-error "No reader for tag #%S in %S" tag (map-keys tag-readers))))))) stack)))) (defun parseedn-read (&optional tag-readers) @@ -117,7 +137,7 @@ identifying *tags*, and values are tag handler functions that receive one argument: *the tagged element*, and specify how to interpret it." (parseclj-parser #'parseedn-reduce-leaf #'parseedn-reduce-branch - (a-list :tag-readers tag-readers))) + (list (cons :tag-readers tag-readers)))) (defun parseedn-read-str (s &optional tag-readers) "Parse string S as EDN. @@ -136,22 +156,58 @@ TAG-READERS is an optional association list. For more information, see (defun parseedn-print-seq (coll) "Insert sequence COLL as EDN into the current buffer." - (parseedn-print (elt coll 0)) - (let ((next (seq-drop coll 1))) - (when (not (seq-empty-p next)) + (when (not (seq-empty-p coll)) + (while (not (seq-empty-p coll)) + (parseedn-print (elt coll 0)) (insert " ") - (parseedn-print-seq next)))) + (setq coll (seq-drop coll 1))) + (delete-char -1))) -(defun parseedn-print-kvs (map) - "Insert hash table MAP as an EDN map into the current buffer." - (let ((keys (a-keys map))) +(defun parseedn-print-hash-or-alist (map &optional ks) + "Insert hash table MAP or elisp alist as an EDN map into the current buffer." + (when-let ((keys (or ks (map-keys map)))) (parseedn-print (car keys)) (insert " ") - (parseedn-print (a-get map (car keys))) + (parseedn-print (map-elt map (car keys))) (let ((next (cdr keys))) (when (not (seq-empty-p next)) (insert ", ") - (parseedn-print-kvs next))))) + (parseedn-print-hash-or-alist map next))))) + +(defun parseedn-print-plist (plist) + "Insert an elisp property list as an EDN map into the current buffer." + (parseedn-print (car plist)) + (insert " ") + (parseedn-print (cadr plist)) + (let ((next (cddr plist))) + (when (not (seq-empty-p next)) + (insert ", ") + (parseedn-print-plist next)))) + +(defun parseedn-print-inst (time) + "Insert an inst value into the current buffer. + +Take an encode-time style value and print it as a timestamp +deliniated by double quotes." + (insert (format-time-string "\"%Y-%m-%dT%T\"" time))) + +(defun parseedn-alist-p (list) + "Non-null if and only if LIST is an alist with simple keys." + (while (consp list) + (setq list (if (and (consp (car list)) + (atom (caar list))) + (cdr list) + 'not-alist))) + (null list)) + +(defun parseedn-plist-p (list) + "Non-null if and only if LIST is a plist with keyword keys." + (while (consp list) + (setq list (if (and (keywordp (car list)) + (consp (cdr list))) + (cddr list) + 'not-plist))) + (null list)) (defun parseedn-print (datum) "Insert DATUM as EDN into the current buffer. @@ -163,32 +219,50 @@ DATUM can be any Emacs Lisp value." ((stringp datum) (insert "\"") (seq-doseq (char datum) - (insert (cl-case char - (?\t "\\t") - (?\f "\\f") - (?\" "\\\"") - (?\r "\\r") - (?\n"foo\t" "\\n") - (?\\ "\\\\") - (t (char-to-string char))))) + (insert (cond + ((eq ?\t char) "\\t") + ((eq ?\f char) "\\f") + ((eq ?\" char) "\\\"") + ((eq ?\r char) "\\r") + ((eq ?\n char) "\\n") + ((eq ?\\ char) "\\\\") + (t (char-to-string char))))) (insert "\"")) ((eq t datum) (insert "true")) - ((symbolp datum) + ((or (keywordp datum) (symbolp datum)) (insert (symbol-name datum))) ((vectorp datum) (insert "[") (parseedn-print-seq datum) (insert "]")) + ((or (hash-table-p datum) (parseedn-alist-p datum)) + (insert "{") + (parseedn-print-hash-or-alist datum) + (insert "}")) + + ((parseedn-plist-p datum) + (insert "{") + (parseedn-print-plist datum) + (insert "}")) + ((consp datum) (cond + ((not (listp (cdr datum))) ; dotted pair + (error "Don't know how to print: %s" datum)) ((eq 'edn-set (car datum)) (insert "#{") (parseedn-print-seq (cadr datum)) (insert "}")) + ((eq 'edn-uuid (car datum)) + (insert "#uuid ") (parseedn-print-seq (cdr datum))) + ((eq 'edn-inst (car datum)) + (insert "#inst ") (parseedn-print-inst (cdr datum))) + ((eq 'edn-tagged-literal (car datum)) + (insert "#" (symbol-name (cadr datum)) " ") + (parseedn-print (caddr datum))) (t (insert "(") (parseedn-print-seq datum) (insert ")")))) - ((hash-table-p datum) - (insert "{") (parseedn-print-kvs datum) (insert "}")))) + (t (error "Don't know how to print: %s" datum)))) (defun parseedn-print-str (datum) "Return a string containing DATUM as EDN. -- 2.47.3