[jdict] jsonpath supports setting value, jdict can use jsonpath in setter, tests

Author: fangq

jdatadecode.m

@@ -345,6 +345,10 @@
     if (len == 1)
         newdata = newdata{1};
     end
+    if (isfield(data, N_('_ArrayLabel_')))
+        newdata = jdict(newdata);
+        newdata{'dims'} = data(j).(N_('_ArrayLabel_'));
+    end
 end
 
 %% handle table data

jdataencode.m

@@ -47,7 +47,7 @@
 %                  struct; otherwise, keep it as map
 %         Compression: ['zlib'|'gzip','lzma','lz4','lz4hc'] - use zlib method
 %                  to compress data array
-%         CompressArraySize: [100|int]: only to compress an array if the
+%         CompressArraySize: [300|int]: only to compress an array if the
 %                  total element count is larger than this number.
 %         FormatVersion [2|float]: set the JSONLab output version; since
 %                  v2.0, JSONLab uses JData specification Draft 1
@@ -86,7 +86,7 @@
 opt.compression = jsonopt('Compression', '', opt);
 opt.nestarray = jsonopt('NestArray', 0, opt);
 opt.formatversion = jsonopt('FormatVersion', 2, opt);
-opt.compressarraysize = jsonopt('CompressArraySize', 100, opt);
+opt.compressarraysize = jsonopt('CompressArraySize', 300, opt);
 opt.base64 = jsonopt('Base64', 0, opt);
 opt.mapasstruct = jsonopt('MapAsStruct', 0, opt);
 opt.usearrayzipsize = jsonopt('UseArrayZipSize', 1, opt);
@@ -102,7 +102,9 @@
 if (iscell(item))
     newitem = cell2jd(item, varargin{:});
 elseif (isa(item, 'jdict'))
-    newitem = obj2jd(item(), varargin{:});
+    attrpath = item.getattr();
+    varargin{1}.annotatearray = ~isempty(attrpath);
+    newitem = obj2jd(item.v(), varargin{:});
 elseif (isstruct(item))
     newitem = struct2jd(item, varargin{:});
 elseif (isnumeric(item) || islogical(item) || isa(item, 'timeseries'))
@@ -125,6 +127,26 @@
     newitem = item;
 end
 
+if (isa(item, 'jdict'))  % apply attribute
+    if (isempty(attrpath))
+        return
+    end
+
+    newitem = jdict(newitem);
+
+    for i = 1:length(attrpath)
+        attr = item.getattr(attrpath{i}).v();
+        attrname = keys(attr);
+        for j = 1:length(attrname)
+            if (strcmp(attrname{j}, 'dims'))
+                newitem.(attrpath{i}).(encodevarname('_ArrayLabel_')) = attr(attrname{j});
+            else
+                newitem.(attrpath{i}).(attrname{j}) = attr(attrname{j});
+            end
+        end
+    end
+end
+
 %% -------------------------------------------------------------------------
 function newitem = cell2jd(item, varargin)
 

jdict.m

@@ -206,7 +206,7 @@
                         tempobj.attr = obj.attr;
                         tempobj.currentpath = trackpath;
                         val = fhandle(tempobj, idxkey(i + 1).subs{:});
-                        if (i == oplen - 1 && strcmp(idx.subs, 'isKey'))
+                        if (i == oplen - 1 && (strcmp(idx.subs, 'isKey') || strcmp(idx.subs, 'getattr')))
                             varargout{1} = val;
                             return
                         end
@@ -431,10 +431,7 @@
                         end
                         continue
                     end
-                    if (ischar(idx.subs) && ~isempty(idx.subs) && idx.subs(1) == char(36))
-                        error('setting values based on JSONPath indices is not yet supported');
-                    end
-                    if (ischar(idx.subs))
+                    if (ischar(idx.subs) && ~(~isempty(idx.subs) && idx.subs(1) == char(36)))
                         if (((isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary')) && ~isKey(opcell{i}, idx.subs)))
                             idx.type = '()';
                             opcell{i}(idx.subs) = obj.newkey_();
@@ -448,7 +445,9 @@
                         end
                     end
                 end
-                if (isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary'))
+                if (ischar(idx.subs) && ~isempty(idx.subs) && idx.subs(1) == char(36))
+                    opcell{i + 1} = obj.call_('jsonpath', opcell{i}, idx.subs);
+                elseif (isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary'))
                     opcell{i + 1} = opcell{i}(idx.subs);
                 else
                     opcell{i + 1} = subsref(opcell{i}, idx);
@@ -459,10 +458,14 @@
                 opcell{i}(idx.subs) = otherobj;
                 opcell{end - 1} = opcell{i};
             else
-                if (isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary'))
-                    idx = struct('type', '()', 'subs', idx.subs);
+                if (ischar(idx.subs) && ~isempty(idx.subs) && idx.subs(1) == char(36))
+                    opcell{end - 1} = obj.call_('jsonpath', opcell{i}, idx.subs, otherobj);
+                else
+                    if (isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary'))
+                        idx = struct('type', '()', 'subs', idx.subs);
+                    end
+                    opcell{end - 1} = subsasgn(opcell{i}, idx, otherobj);
                 end
-                opcell{end - 1} = subsasgn(opcell{i}, idx, otherobj);
             end
 
             for i = oplen - 1:-1:1
@@ -483,6 +486,8 @@
                         opcell{i} = opcell{i + 1};
                     end
                     i = i - 1;
+                elseif (ischar(idx.subs) && ~isempty(idx.subs) && idx.subs(1) == char(36))
+                    opcell{i} = obj.call_('jsonpath', opcell{i}, idx.subs, opcell{i + 1});
                 else
                     opcell{i} = subsasgn(opcell{i}, idx, opcell{i + 1});
                 end
@@ -494,7 +499,7 @@
         % export data to json
         function val = tojson(obj, varargin)
             % printing underlying data to compact-formed JSON string
-            val = obj.call_('savejson', '', obj.data, 'compact', 1, varargin{:});
+            val = obj.call_('savejson', '', obj, 'compact', 1, varargin{:});
         end
 
         % load data from over a dozen data formats, including json and binary json
@@ -611,15 +616,21 @@
                 return
             end
             if (nargin == 2)
-                attrname = jsonpath;
-                jsonpath = obj.currentpath;
+                if (~isempty(jsonpath) && jsonpath(1) ~= char(36))
+                    attrname = jsonpath;
+                    jsonpath = obj.currentpath;
+                else
+                    attrname = '';
+                end
             end
             if (~isKey(obj.attr, jsonpath))
                 val = [];
                 return
             end
             attrmap = obj.attr(jsonpath);
-            if (isKey(attrmap, attrname))
+            if (isempty(attrname))
+                val = attrmap;
+            elseif (isKey(attrmap, attrname))
                 val = attrmap(attrname);
             else
                 val = [];

jsonpath.m

@@ -1,14 +1,18 @@
 function obj = jsonpath(root, jpath, varargin)
 %
 %    obj=jsonpath(root, jpath)
+%    obj=jsonpath(root, jpath, newvalue)
 %
-%    Query and retrieve elements from matlab data structures using JSONPath
+%    Getting or setting data elements from matlab data structures using
+%    JSONPath
 %
 %    author: Qianqian Fang (q.fang <at> neu.edu)
 %
 %    input:
 %        root: a matlab data structure like an array, cell, struct, etc
 %        jpath: a string in the format of JSONPath, see loadjson help
+%        newvalue: if present, the data specified at the path jpath will be
+%               replaced by newvalue
 %
 %    output:
 %        obj: if the specified element exist, obj returns the result
@@ -34,11 +38,29 @@
     if (strcmp(paths{1}, '$'))
         paths(1) = [];
     end
-    for i = 1:length(paths)
-        [obj, isfound] = getonelevel(obj, paths, i, varargin{:});
-        if (~isfound)
-            return
+    if (isempty(varargin))
+        for i = 1:length(paths)
+            [obj, isfound] = getonelevel(obj, paths, i, varargin{:});
+            if (~isfound)
+                return
+            end
+        end
+    else
+        datastack = cell(1, length(paths) + 1);
+        datastack{1} = obj;
+        for i = 1:length(paths)
+            [datastack{i + 1}, isfound] = getonelevel(datastack{i}, paths, i, varargin{:});
+            if (~isfound)
+                error(['data with a jsonpath ' jpath ' does not exist']);
+            end
+        end
+        idx = struct('type', '.', 'subs', paths{end}{1}(2:end));
+        datastack{end - 1} = subsasgn(jdict(datastack{i}), idx, varargin{1});
+        for i = length(paths) - 1:-1:1
+            idx = struct('type', '.', 'subs', paths{i}{1}(2:end));
+            datastack{i} = subsasgn(jdict(datastack{i}), idx, datastack{i + 1}.v());
         end
+        obj = datastack{1}.v();
     end
 end
 
@@ -118,7 +140,7 @@
     else
         obj = input(arrayrange.start:arrayrange.end);
     end
-elseif (isstruct(input) || isa(input, 'containers.Map') || isa(input, 'table'))
+elseif (isstruct(input) || isa(input, 'containers.Map') || isa(input, 'table') || isa(input, 'jdict'))
     pathname = regexprep(pathname, '^\[(.*)\]$', '$1');
     stpath = encodevarname(pathname);
     if (isstruct(input))

savejson.m

@@ -88,7 +88,7 @@
 %                            array dimensions, and
 %                         "_ArrayZipData_": the "base64" encoded
 %                             compressed binary array data.
-%           CompressArraySize [100|int]: only to compress an array if the total
+%           CompressArraySize [300|int]: only to compress an array if the total
 %                         element count is larger than this number.
 %           CompressStringSize [inf|int]: only to compress a string if the total
 %                         element count is larger than this number.
@@ -155,13 +155,13 @@
 
 opt.isoctave = isoctavemesh;
 
-opt.compression = jsonopt('Compression', '', opt);
+opt.compression = jsonopt('Compression', 'zlib', opt);
 opt.nestarray = jsonopt('NestArray', 0, opt);
 opt.compact = jsonopt('Compact', 0, opt);
 opt.singletcell = jsonopt('SingletCell', 1, opt);
 opt.singletarray = jsonopt('SingletArray', 0, opt);
 opt.formatversion = jsonopt('FormatVersion', 3, opt);
-opt.compressarraysize = jsonopt('CompressArraySize', 100, opt);
+opt.compressarraysize = jsonopt('CompressArraySize', 300, opt);
 opt.compressstringsize = jsonopt('CompressStringSize', inf, opt);
 opt.intformat = jsonopt('IntFormat', '%.0f', opt);
 opt.floatformat = jsonopt('FloatFormat', '%.16g', opt);
@@ -304,7 +304,7 @@
 if (iscell(item) || (isa(item, 'string') && numel(item) > 1))
     txt = cell2json(name, item, level, varargin{:});
 elseif (isa(item, 'jdict'))
-    txt = obj2json(name, item, level, varargin{:});
+    txt = obj2json(name, item.v(), level, varargin{:});
 elseif (isstruct(item))
     txt = struct2json(name, item, level, varargin{:});
 elseif (isnumeric(item) || islogical(item) || isa(item, 'timeseries'))

test/run_jsonlab_test.m

@@ -3,7 +3,7 @@ function run_jsonlab_test(tests)
 % run_jsonlab_test
 %   or
 % run_jsonlab_test(tests)
-% run_jsonlab_test({'js','jso','bj','bjo','jmap','bmap','jpath','jdict','bugs'})
+% run_jsonlab_test({'js','jso','bj','bjo','jmap','bmap','jpath','jdict','bugs','yaml','yamlopt','xarray'})
 %
 % Unit testing for JSONLab JSON, BJData/UBJSON encoders and decoders
 %
@@ -21,6 +21,9 @@ function run_jsonlab_test(tests)
 %         'jpath': test jsonpath
 %         'jdict': test jdict
 %         'bugs': test specific bug fixes
+%         'yaml': test yaml reader/writer
+%         'yamlopt': test yaml handling options
+%         'xarray': test jdict data attribute operations
 %
 % license:
 %     BSD or GPL version 3, see LICENSE_{BSD,GPLv3}.txt files for details
@@ -461,6 +464,19 @@ function run_jsonlab_test(tests)
     jd.('key1').('subkey3').v(3).('subsubkey2') = 'new';
     test_jsonlab('jd.(''key1'').(''subkey3'')', @savejson, jd.('key1').('subkey3'), '[8,"mod",{"subsubkey1":1,"subsubkey2":"new"}]', 'compact', 1);
     test_jsonlab('jd.(''key1'').(''subkey2'')', @savejson, jd.('key1').('subkey2'), '[2,10,11]', 'compact', 1);
+    test_jsonlab('jd.(''key1'').(''subkey2'').len()', @savejson, jd.('key1').('subkey2').len(), '[3]', 'compact', 1);
+    test_jsonlab('jd.(''key1'').(''subkey2'').size()', @savejson, jd.('key1').('subkey2').size(), '[1,3]', 'compact', 1);
+    test_jsonlab('jd.(''key1'').keys()', @savejson, jd.('key1').keys(), '[["subkey1"],["subkey2"],["subkey3"]]', 'compact', 1);
+    test_jsonlab('jd.(''key1'').isKey(''subkey3'')', @savejson, jd.('key1').isKey('subkey3'), '[true]', 'compact', 1);
+    test_jsonlab('jd.(''key1'').isKey(''subkey4'')', @savejson, jd.('key1').isKey('subkey4'), '[false]', 'compact', 1);
+
+    jd.('$.key1.subkey1') = [1, 2, 3];
+    test_jsonlab('jd.(''$.key1.subkey1'')', @savejson, jd.('key1').('subkey1'), '[1,2,3]', 'compact', 1);
+    jd.key1.('$.subkey1') = 'newsubkey1';
+    test_jsonlab('jd.key1.(''$.subkey1'')', @savejson, jd.('key1').('subkey1'), '"newsubkey1"', 'compact', 1);
+    jd.('$.key1').subkey1 = struct('newkey', 1);
+    test_jsonlab('jd.(''$.key1'').subkey1', @savejson, jd.('key1').('subkey1'), '{"newkey":1}', 'compact', 1);
+    test_jsonlab('jd.(''$.key1.subkey1'').newkey', @savejson, jd.('key1').('subkey1').newkey, '[1]', 'compact', 1);
 
     clear testdata jd;
 end
@@ -702,13 +718,13 @@ function run_jsonlab_test(tests)
         jd7.('data'){'dims'} = {'x', 'y'};
         jd7.('data'){'sampling_rate'} = 1000;
     end
-    r11a = jd7.('data'){'dims'};
-    r11b = jd7.('data'){'sampling_rate'};
-    if (iscell(r11a) && r11b == 1000)
-        fprintf(1, 'Testing attr persistence: ok\n');
-    else
-        warning('Test attr persistence: failed');
-    end
+    test_jsonlab('dims attribute in level 1', @savejson, jd7.('data'){'dims'}, '["x","y"]', 'compact', 1);
+    test_jsonlab('other attribute in level 1', @savejson, jd7.('data'){'sampling_rate'}, '[1000]', 'compact', 1);
+    test_jsonlab('getattr list top attr key', @savejson, jd7.getattr(), '["$.data"]', 'compact', 1);
+    test_jsonlab('getattr return all attributes', @savejson, jd7.getattr('$.data').v(), '{"dims":["x","y"],"sampling_rate":1000}', 'compact', 1);
+    test_jsonlab('getattr get one attr', @savejson, jd7.getattr('$.data', 'dims').v(), '["x","y"]', 'compact', 1);
+    test_jsonlab('savejson with _ArrayLabel_', @savejson, jd7, '{"data":{"_ArrayType_":"double","_ArraySize_":[3,4],"_ArrayData_":[1,1,1,1,1,1,1,1,1,1,1,1],"_ArrayLabel_":["x","y"],"sampling_rate":1000}}', 'compact', 1);
+    test_jsonlab('loadjson with _ArrayLabel_', @savejson, loadjson(jd7.tojson()).data.getattr('$', 'dims'), '["x","y"]', 'compact', 1);
 
     % Test 12: Multiple attributes different types
     jd8 = jdict(rand(10, 20));