From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!.POSTED!not-for-mail From: =?utf-8?B?Sm/Do28gVMOhdm9yYQ==?= Newsgroups: gmane.emacs.devel Subject: [PATCH] Accept plists when serializing and parsing JSON Date: Tue, 29 May 2018 15:59:06 +0100 Message-ID: <87sh6awls5.fsf@gmail.com> NNTP-Posting-Host: blaine.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" X-Trace: blaine.gmane.org 1527605847 7450 195.159.176.226 (29 May 2018 14:57:27 GMT) X-Complaints-To: usenet@blaine.gmane.org NNTP-Posting-Date: Tue, 29 May 2018 14:57:27 +0000 (UTC) User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.0.50 (gnu/linux) To: emacs-devel@gnu.org Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Tue May 29 16:57:23 2018 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by blaine.gmane.org with esmtp (Exim 4.84_2) (envelope-from ) id 1fNg3u-0001og-4e for ged-emacs-devel@m.gmane.org; Tue, 29 May 2018 16:57:22 +0200 Original-Received: from localhost ([::1]:33410 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fNg61-0007sV-D6 for ged-emacs-devel@m.gmane.org; Tue, 29 May 2018 10:59:33 -0400 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:44227) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fNg5t-0007qs-98 for emacs-devel@gnu.org; Tue, 29 May 2018 10:59:27 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fNg5o-0002AP-6k for emacs-devel@gnu.org; Tue, 29 May 2018 10:59:25 -0400 Original-Received: from mail-wm0-x22c.google.com ([2a00:1450:400c:c09::22c]:55535) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1fNg5n-00029v-Qr for emacs-devel@gnu.org; Tue, 29 May 2018 10:59:20 -0400 Original-Received: by mail-wm0-x22c.google.com with SMTP id a8-v6so41473159wmg.5 for ; Tue, 29 May 2018 07:59:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:user-agent:date:message-id:mime-version; bh=vIBojGrLm3orsKXx+uWg3U5S5OrkEXeteZXZqDHXRgQ=; b=m2zTe9DISy3QewRRZwng8wiueAD1K/dsaJJUKF7Nj82DWGFssrg2NDN4wcCoUnUxAv 0aG0EoyoZ44ONrQpUbosTXqr0WG7ELtCS9oI/IK81EGzWvAr0Jq2OV/fPfRzVmbH6lQt WjpenTs/NZs0jM7521LU51M5NK0oCfN1CRC6lxd6IDI0TZl2VFxQMzQFM+xZv7fAfHBy 4BlDIe+aAq4MlKYBOFTHF9Mkip5Cec336CqOSrAoTe3fEuTY3frTaHujhyn59x/+/Bgh ZkTuD21MokNDeyj+dXphS6D4e+DK5mtFb6ak4FqAQBNUa7knAh+NefGJM6YDty2KckWa +cEA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:user-agent:date:message-id :mime-version; bh=vIBojGrLm3orsKXx+uWg3U5S5OrkEXeteZXZqDHXRgQ=; b=VDRGvX40exPJOoC96o4u1QnHFtl7u2Be9lfOa9QY4nx0yoTq6xiO1C/S6Qkv76GwzM 5sP58aP6mfXO2Q/98FwsNuUmZbCiZ/PxBYW8zxT/PvM7kJR7lkl7Txm7wFNcL5AXCX+s vfXGf5NdZdxrao3o+UXZvKllT0/qM8MvFQ/OY8PB7xyeq+kWoZye4kINSMmMQtDnIOiU j7jT1Mkn4ndXD8d8yBuB2X7b3fYmWoSIUGmVYr8ahT1Auu8daQzGcI8z32vqvASxaJKE KylYfLBzUoiGHlgqCvlsPuMJpL4JCd6qLLqVZqRbShiL2tyuYFWMZ0KbqAXQnbEMRC1Q y9gg== X-Gm-Message-State: ALKqPwddW5jhHz8tAqND7JkjsvxjLcEwb7nfbrv5JVXeThHJYUZZHLa3 Oe983fZ9Yxu/A4SqOx1dpKBz1gxk X-Google-Smtp-Source: ADUXVKJ5mEsZijrJbdU/NszntS0RfWZu0N4vqcIGUwUaLFxzogKRddJpLb+rMUI6UanBLLX+cviyFg== X-Received: by 2002:a1c:ae0c:: with SMTP id x12-v6mr13652216wme.133.1527605958400; Tue, 29 May 2018 07:59:18 -0700 (PDT) Original-Received: from lolita.yourcompany.com (188.139.62.94.rev.vodafone.pt. [94.62.139.188]) by smtp.gmail.com with ESMTPSA id n71-v6sm20973818wmi.14.2018.05.29.07.59.16 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Tue, 29 May 2018 07:59:17 -0700 (PDT) X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2a00:1450:400c:c09::22c X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Original-Sender: "Emacs-devel" Xref: news.gmane.org gmane.emacs.devel:225800 Archived-At: --=-=-= Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Hi, So I found this other thread https://lists.gnu.org/archive/html/emacs-devel/2017-12/msg00667.html where plist support for json.c is briefly requested and discussed, but there didn't seem to be an overwhelming argument against it, so I had another look at the file and it didn't seem very hard or problematic to implement. Anyway, I had a go. It's small, so have a look. Patch at the end of this file, or find it in the scratch/support-plists-in-jsonc branch. I used a global to control json-serialize's interpretation of lists, but it could be an argument as well. Added some tests and some doc, too. Jo=C3=A3o PS: Take this opportunity to thank Eli and everyone else very much for the Emacs 26.1 release! --=-=-= Content-Type: text/x-diff Content-Disposition: inline; filename=0001-Support-plists-in-json.c.patch >From 224f8ea95f00cc60ee77aeaad6585bb2ef845f70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20T=C3=A1vora?= Date: Tue, 29 May 2018 15:41:30 +0100 Subject: [PATCH] Support plists in json.c * doc/lispref/text.texi (Parsing JSON): Mention plists and json-serialize-use-plists. * src/json.c (lisp_to_json_toplevel_1): Decide with Vjson_serialize_use_plists. (Fjson_serialize): Update docstring. (enum json_object_type): Add json_object_plist. (json_to_lisp): Can build plists. (json_parse_object_type): Accept plists. (Fjson_parse_string): Update docstring. (json-serialize-use-plist): New DEFVAR_LISP. (Qplist): New sym_of_json * test/src/json-tests.el (json-serialize/object): Do some tests with json-serialize-use-plists to t. (json-parse-string/object): Parse something as a plist. --- doc/lispref/text.texi | 27 ++++++++---- src/json.c | 97 ++++++++++++++++++++++++++++++++---------- test/src/json-tests.el | 18 +++++++- 3 files changed, 110 insertions(+), 32 deletions(-) diff --git a/doc/lispref/text.texi b/doc/lispref/text.texi index da09b4ae1c..3995102237 100644 --- a/doc/lispref/text.texi +++ b/doc/lispref/text.texi @@ -5025,16 +5025,18 @@ Parsing JSON @item JSON has only one map type, the object. JSON objects are represented -using Lisp hashtables or alists. When an alist contains several -elements with the same key, Emacs uses only the first element for -serialization, in accordance with the behavior of @code{assq}. +using Lisp hashtables, alists or plists. When an alist or plist +contains several elements with the same key, Emacs uses only the first +element for serialization, in accordance with the behavior of +@code{assq}. @end itemize @noindent -Note that @code{nil} is a valid alist and represents the empty JSON -object, @code{@{@}}, not @code{null}, @code{false}, or an empty array, -all of which are different JSON values. +Note that @code{nil} is both a valid alist and a valid plist and +represents the empty JSON object, @code{@{@}}, not @code{null}, +@code{false}, or an empty array, all of which are different JSON +values. If some Lisp object can't be represented in JSON, the serialization functions will signal an error of type @code{wrong-type-argument}. @@ -5057,12 +5059,21 @@ Parsing JSON Only top-level values (arrays and objects) can be serialized to JSON. The subobjects within these top-level values can be of any type. Likewise, the parsing functions will only return vectors, -hashtables, and alists. +hashtables, alists and plists. The parsing functions accept keyword arguments. Currently only one keyword argument, @code{:object-type}, is recognized; its value can be either @code{hash-table} to parse JSON objects as hashtables with -string keys (the default) or @code{alist} to parse them as alists. +string keys (the default), @code{alist} to parse them as alists or +@code{plist} to parse them as plists. + +@vindex json-serialize-use-plists +@cindex serializing plists as json + For the serialization function, the variable +@var{json-serialize-use-plists} controls the converse process, +resolving the ambiguity when a list is found in the Lisp object to +serialize. If @code{nil}, its default, the list is interpreted as an +alist, otherwise it is interpreted as a plist. @defun json-serialize object This function returns a new Lisp string which contains the JSON diff --git a/src/json.c b/src/json.c index b046d34f66..ccd58c047e 100644 --- a/src/json.c +++ b/src/json.c @@ -395,16 +395,31 @@ lisp_to_json_toplevel_1 (Lisp_Object lisp, json_t **json) record_unwind_protect_ptr (json_release_object, *json); FOR_EACH_TAIL (tail) { - Lisp_Object pair = XCAR (tail); - CHECK_CONS (pair); - Lisp_Object key_symbol = XCAR (pair); - Lisp_Object value = XCDR (pair); + const char *key_str; + Lisp_Object value; + Lisp_Object key_symbol; + if ( EQ (Vjson_serialize_use_plists, Qt) ) { + key_symbol = XCAR (tail); + tail = XCDR(tail); + CHECK_CONS (tail); + value = XCAR (tail); + if (EQ (tail, li.tortoise)) circular_list (lisp); + } else { + Lisp_Object pair = XCAR (tail); + CHECK_CONS (pair); + key_symbol = XCAR (pair); + value = XCDR (pair); + } CHECK_SYMBOL (key_symbol); Lisp_Object key = SYMBOL_NAME (key_symbol); /* We can't specify the length, so the string must be null-terminated. */ check_string_without_embedded_nulls (key); - const char *key_str = SSDATA (key); + key_str = SSDATA (key); + /* If using plists, maybe strip the ":" from symbol-name */ + if (EQ (Vjson_serialize_use_plists, Qt) && + ':' == key_str[0] && + key_str[1] ) key_str = &key_str[1]; /* Only add element if key is not already present. */ if (json_object_get (*json, key_str) == NULL) { @@ -476,13 +491,17 @@ lisp_to_json (Lisp_Object lisp) DEFUN ("json-serialize", Fjson_serialize, Sjson_serialize, 1, 1, NULL, doc: /* Return the JSON representation of OBJECT as a string. -OBJECT must be a vector, hashtable, or alist, and its elements can -recursively contain `:null', `:false', t, numbers, strings, or other -vectors hashtables, and alist. `:null', `:false', and t will be -converted to JSON null, false, and true values, respectively. Vectors -will be converted to JSON arrays, and hashtables and alists to JSON -objects. Hashtable keys must be strings without embedded null -characters and must be unique within each object. Alist keys must be + +OBJECT must be a vector of values or a key-value map. Hashtables, +alists and plists are accepted as maps, the variable +`json-serialize-use-plists' controlling which one of the latter two to +use. In any of these cases, values can be `:null', `:false', t, +numbers, strings, or, recursively, other vectors, hashtables, alists +or plists. `:null', `:false', and t will be converted to JSON null, +false, and true values, respectively. Vectors will be converted to +JSON arrays, and hashtables, alists and plists to JSON objects. +Hashtable keys must be strings without embedded null characters and +must be unique within each object. Alist or plist keys must be symbols; if a key is duplicate, the first instance is used. */) (Lisp_Object object) { @@ -605,6 +624,7 @@ OBJECT. */) enum json_object_type { json_object_hashtable, json_object_alist, + json_object_plist }; /* Convert a JSON object to a Lisp object. */ @@ -692,6 +712,30 @@ json_to_lisp (json_t *json, enum json_object_type object_type) result = Fnreverse (result); break; } + case json_object_plist: + { + result = Qnil; + const char *key_str; + json_t *value; + json_object_foreach (json, key_str, value) + { + /* No idea if using AUTO_STRING and Fconcat for + making keywords is idiomatic, but seems to work + nicely */ + AUTO_STRING (colon, ":"); + Lisp_Object key = + Fintern (CALLN (Fconcat, colon, json_build_string (key_str)) + , Qnil); + result = Fcons (key, result); /* build the plist as + value-key since + we're going to + reverse it in the + end.*/ + result = Fcons (json_to_lisp (value, object_type), result); + } + result = Fnreverse (result); + break; + } default: /* Can't get here. */ emacs_abort (); @@ -721,8 +765,10 @@ json_parse_object_type (ptrdiff_t nargs, Lisp_Object *args) return json_object_hashtable; else if (EQ (value, Qalist)) return json_object_alist; + else if (EQ (value, Qplist)) + return json_object_plist; else - wrong_choice (list2 (Qhash_table, Qalist), value); + wrong_choice (list3 (Qhash_table, Qalist, Qplist), value); } default: wrong_type_argument (Qplistp, Flist (nargs, args)); @@ -733,15 +779,16 @@ DEFUN ("json-parse-string", Fjson_parse_string, Sjson_parse_string, 1, MANY, NULL, doc: /* Parse the JSON STRING into a Lisp object. This is essentially the reverse operation of `json-serialize', which -see. The returned object will be a vector, hashtable, or alist. Its -elements will be `:null', `:false', t, numbers, strings, or further -vectors, hashtables, and alists. If there are duplicate keys in an -object, all but the last one are ignored. If STRING doesn't contain a -valid JSON object, an error of type `json-parse-error' is signaled. -The keyword argument `:object-type' specifies which Lisp type is used -to represent objects; it can be `hash-table' or `alist'. -usage: (json-parse-string STRING &key (OBJECT-TYPE \\='hash-table)) */) - (ptrdiff_t nargs, Lisp_Object *args) +see. The returned object will be a vector, hashtable, alist, or +plist. Its elements will be `:null', `:false', t, numbers, strings, +or further vectors, hashtables, alists, or plists. If there are +duplicate keys in an object, all but the last one are ignored. If +STRING doesn't contain a valid JSON object, an error of type +`json-parse-error' is signaled. The keyword argument `:object-type' +specifies which Lisp type is used to represent objects; it can be +`hash-table', `alist' or `plist'. +usage: (json-parse-string STRING &key (OBJECT-TYPE \\='hash-table)) */) + (ptrdiff_t nargs, Lisp_Object *args) { ptrdiff_t count = SPECPDL_INDEX (); @@ -903,6 +950,11 @@ syms_of_json (void) DEFSYM (Qpure, "pure"); DEFSYM (Qside_effect_free, "side-effect-free"); + DEFVAR_LISP ("json-serialize-use-plists", Vjson_serialize_use_plists, + doc: + /* If non-nil use plists instead of alists in json-serialize.*/); + Vjson_serialize_use_plists = Qnil; + DEFSYM (Qjson_serialize, "json-serialize"); DEFSYM (Qjson_parse_string, "json-parse-string"); Fput (Qjson_serialize, Qpure, Qt); @@ -912,6 +964,7 @@ syms_of_json (void) DEFSYM (QCobject_type, ":object-type"); DEFSYM (Qalist, "alist"); + DEFSYM (Qplist, "plist"); defsubr (&Sjson_serialize); defsubr (&Sjson_insert); diff --git a/test/src/json-tests.el b/test/src/json-tests.el index 09067bad8c..5c9be20e95 100644 --- a/test/src/json-tests.el +++ b/test/src/json-tests.el @@ -69,7 +69,19 @@ 'json-tests--error (should-error (json-serialize '((1 . 2))) :type 'wrong-type-argument) (should-error (json-serialize '((a . 1) . b)) :type 'wrong-type-argument) (should-error (json-serialize '#1=((a . 1) . #1#)) :type 'circular-list) - (should-error (json-serialize '(#1=(a #1#))))) + (should-error (json-serialize '(#1=(a #1#)))) + + (let ((json-serialize-use-plists t)) + (should (equal (json-serialize '(:abc [1 2 t] :def :null)) + "{\"abc\":[1,2,true],\"def\":null}")) + (should (equal (json-serialize '(abc [1 2 t] :def :null)) + "{\"abc\":[1,2,true],\"def\":null}")) + (should-error (json-serialize '#1=(:a 1 . #1#)) :type 'circular-list) + (should-error (json-serialize '((abc . 1))) :type 'wrong-type-argument) + (should-error (json-serialize '(:foo bar (abc . 1))) + :type 'wrong-type-argument) + (should-error (json-serialize '(:foo bar :odd-numbered)) + :type 'wrong-type-argument))) (ert-deftest json-serialize/object-with-duplicate-keys () (skip-unless (fboundp 'json-serialize)) @@ -89,7 +101,9 @@ 'json-tests--error (should (equal (cl-sort (map-pairs actual) #'string< :key #'car) '(("abc" . [9 :false]) ("def" . :null))))) (should (equal (json-parse-string input :object-type 'alist) - '((abc . [9 :false]) (def . :null)))))) + '((abc . [9 :false]) (def . :null)))) + (should (equal (json-parse-string input :object-type 'plist) + '(:abc [9 :false] :def :null))))) (ert-deftest json-parse-string/string () (skip-unless (fboundp 'json-parse-string)) -- 2.17.0 --=-=-=--