[jdict] new feature: schema-guarded assignment, jd.key <= value, with tests

Author: fangq

jdict.m

@@ -166,6 +166,7 @@
     properties (Access = private)
         flags__          % additional options, will be passed to jsonlab utility functions such as savejson/loadjson
         currentpath__    % internal variable tracking the current path when lookup embedded data at current depth
+        root__           % reference to root jdict object for validated assignment
     end
     methods
 
@@ -175,6 +176,7 @@
             obj.attr = containers.Map();
             obj.schema = [];
             obj.currentpath__ = char(36);
+            obj.root__ = obj;
             if (nargin >= 1)
                 if (~isempty(varargin))
                     allflags = [varargin(1:2:end); varargin(2:2:end)];
@@ -321,6 +323,7 @@
                             newobj.attr = obj.attr;
                             newobj.schema = obj.schema;
                             newobj.currentpath__ = trackpath;
+                            newobj.root__ = obj.root__;
                             val = newobj;
                             i = i + 2;
                             continue
@@ -381,7 +384,8 @@
                     end
                 end
                 newobj.schema = obj.schema;
-                newobj.currentpath__ = char(36);
+                newobj.currentpath__ = trackpath;
+                newobj.root__ = obj.root__;
                 val = newobj;
             end
             varargout{1} = val;
@@ -576,7 +580,11 @@
                     opcell{i} = obj.call_('jsonpath', opcell{i}, idx.subs, opcell{i + 1});
                 else
                     try
-                        opcell{i} = subsasgn(opcell{i}, idx, opcell{i + 1});
+                        if (exist('OCTAVE_VERSION', 'builtin') ~= 0) && (isa(opcell{i}, 'containers.Map') || isa(opcell{i}, 'dictionary'))
+                            opcell{i}(idx.subs) = opcell{i + 1};
+                        else
+                            opcell{i} = subsasgn(opcell{i}, idx, opcell{i + 1});
+                        end
                     catch
                         opcell{i}.(idx.subs) = opcell{i + 1};
                     end
@@ -793,19 +801,22 @@
 
         % validate data against JSON Schema
         function errors = validate(obj, schemadata)
-            % determine which schema to use
-            if (nargin >= 2 && ~isempty(schemadata))
-                useschema = schemadata;
-            else
-                useschema = obj.schema;
+            if nargin >= 2 && ~isempty(schemadata)
+                obj.setschema(schemadata);
             end
 
-            if (isempty(useschema))
+            if isempty(obj.schema)
                 error('No schema available. Use setschema() first or provide schema as argument.');
             end
 
-            % use standalone jsonschema function
-            [valid, errors] = jsonschema(obj.data, useschema);
+            subschema = jsonschema(obj.schema, [], 'getsubschema', obj.currentpath__);
+
+            if isempty(subschema)
+                errors = {};
+                return
+            end
+
+            [temp, errors] = jsonschema(obj.data, subschema, 'rootschema', obj.schema);
         end
 
         % convert attributes to JSON Schema
@@ -922,5 +933,35 @@
             end
         end
 
+        % overload <= operator for schema-validated assignment
+        function result = le(obj, value)
+            % validate against schema if defined
+            if ~isempty(obj.schema)
+                subschema = jsonschema(obj.schema, [], 'getsubschema', obj.currentpath__);
+
+                % if subschema found for this path, validate
+                if ~isempty(subschema)
+                    [valid, errs] = jsonschema(value, subschema, 'rootschema', obj.schema);
+                    if ~valid
+                        errmsg = sprintf('Schema validation failed for "%s":', obj.currentpath__);
+                        for i = 1:length(errs)
+                            errmsg = [errmsg ' ' errs{i} ';'];
+                        end
+                        error(errmsg);
+                    end
+                end
+            end
+
+            % assign via root object using JSONPath
+            if strcmp(obj.currentpath__, char(36))
+                obj.root__.data = value;
+            else
+                idx.type = '.';
+                idx.subs = obj.currentpath__;
+                subsasgn(obj.root__, idx, value);
+            end
+            result = obj;
+        end
+
     end
 end

jsonschema.m

@@ -30,6 +30,20 @@
 
 opt = varargin2struct(varargin{:});
 
+% Expose resolveref for external use
+if isfield(opt, 'resolveref')
+    valid = resolveref(opt.resolveref, data);
+    errors = {};
+    return
+end
+
+% Expose getsubschema for external use: jsonschema(schema, [], 'getsubschema', '$.path')
+if isfield(opt, 'getsubschema')
+    valid = getsubschema(data, opt.getsubschema);
+    errors = {};
+    return
+end
+
 % Generation mode: jsonschema(schema) or jsonschema(schema, [])
 if nargin == 1 || (nargin >= 2 && isempty(schema))
     schemaarg = data;
@@ -818,3 +832,60 @@
         val.(genvarname(reqfields{i})) = [];
     end
 end
+
+%%
+function subschema = getsubschema(schema, jsonpath)
+
+subschema = schema;
+if isempty(schema) || isempty(jsonpath) || strcmp(jsonpath, '$')
+    return
+end
+
+% Parse path after $.
+path = regexprep(jsonpath, '^\$\.?', '');
+if isempty(path)
+    return
+end
+
+% Tokenize: split by unescaped dots and array indices
+tokens = regexp(path, '(?:\\.|[^\.\[]+|\[\d+\])', 'match');
+
+for i = 1:length(tokens)
+    tok = tokens{i};
+
+    % Resolve $ref if present
+    while isa(subschema, 'containers.Map') && isKey(subschema, '$ref')
+        subschema = resolveref(subschema('$ref'), schema);
+        if isempty(subschema)
+            return
+        end
+    end
+
+    if tok(1) == '['
+        % Array index -> use items schema
+        if isa(subschema, 'containers.Map') && isKey(subschema, 'items')
+            subschema = subschema('items');
+            if iscell(subschema) && ~isempty(subschema)
+                subschema = subschema{1};
+            end
+        else
+            subschema = [];
+            return
+        end
+    else
+        % Property name (unescape \.)
+        prop = strrep(tok, '\.', '.');
+        if isa(subschema, 'containers.Map') && isKey(subschema, 'properties')
+            props = subschema('properties');
+            if isa(props, 'containers.Map') && isKey(props, prop)
+                subschema = props(prop);
+            else
+                subschema = [];
+                return
+            end
+        else
+            subschema = [];
+            return
+        end
+    end
+end