Reworking refScope to be fixed instead of search based.

Author: Peter Amstutz

schema_salad/metaschema/metaschema.yml

@@ -139,16 +139,17 @@ $graph:
         the item is transformed to a JSON object with the key assigned to the
         field specified by `mapSubject` and the value assigned to the field
         specified by `mapPredicate`.
-    - name: scopedRef
-      type: ["null", boolean]
+    - name: refScope
+      type:
+        - "null"
+        - int
       doc: |
-        If the field contains a relative reference, it must be resolved by
-        searching for valid document references in each successive parent
-        scope.  For example, a reference of "foo" in the context "#foo/bar/baz"
-        will first check for the existence of "#foo/bar/baz/foo", followed
-        by "#foo/bar/foo", then "#foo/foo" and then finally "#foo".  The first
-        valid URI in the search order shall be used as the fully resolved value
-        of the identifier.
+        Remove the specified number of layers from the containing identifer
+        scope and join with the field value to yield the identifier.  For
+        example, an identifer scope of `#foo/bar/baz`, `refScope: 0` and
+        identifier `quux` will yield `#foo/bar/baz/quux`.  `refScope: 1` will
+        yield `#foo/bar/quux`, `refScope: 2` will yield `#foo/quux` and so
+        forth.
 
 - name: SpecializeDef
   type: record

schema_salad/ref_resolver.py

@@ -94,7 +94,7 @@ def __init__(self, ctx, schemagraph=None, foreign_properties=None,
             self.cache = {}
 
         self.url_fields = None  # type: Set[str]
-        self.scoped_ref_fields = None  # type: Set[str]
+        self.scoped_ref_fields = None  # type: Dict[unicode, unicode]
         self.vocab_fields = None  # type: Set[str]
         self.identifiers = None  # type: Set[str]
         self.identity_links = None  # type: Set[str]
@@ -187,7 +187,7 @@ def add_context(self, newcontext, baseuri=""):
                 "Refreshing context that already has stuff in it")
 
         self.url_fields = set()
-        self.scoped_ref_fields = set()
+        self.scoped_ref_fields = {}
         self.vocab_fields = set()
         self.identifiers = set()
         self.identity_links = set()
@@ -208,8 +208,8 @@ def add_context(self, newcontext, baseuri=""):
                 self.identity_links.add(key)
             elif isinstance(value, dict) and value.get("@type") == "@id":
                 self.url_fields.add(key)
-                if value.get("scopedRef", False):
-                    self.scoped_ref_fields.add(key)
+                if value.get("refScope", False):
+                    self.scoped_ref_fields[key] = value["refScope"]
                 if value.get("identity", False):
                     self.identity_links.add(key)
             elif isinstance(value, dict) and value.get("@type") == "@vocab":
@@ -376,7 +376,8 @@ def resolve_all(self, document, base_url, file_base=None, checklinks=True):
                     "$import" not in document[idmapField] and
                     "$include" not in document[idmapField]):
                     ls = []
-                    for k, v in document[idmapField].items():
+                    for k in sorted(document[idmapField].keys()):
+                        v = document[idmapField][k]
                         if not isinstance(v, dict):
                             if idmapField in loader.mapPredicate:
                                 v = {loader.mapPredicate[idmapField]: v}
@@ -547,10 +548,16 @@ def validate_link(self, field, link, docid):
                 if field in self.scoped_ref_fields:
                     split = urlparse.urlsplit(docid)
                     sp = split.fragment.split("/")
+                    print field, self.scoped_ref_fields[field], sp
+                    if self.scoped_ref_fields[field] in ("grandparent"):
+                        sp.pop()
+                    if self.scoped_ref_fields[field] in ("parent", "grandparent"):
+                        sp.pop()
                     while True:
                         sp.append(str(link))
                         url = urlparse.urlunsplit(
                             (split.scheme, split.netloc, split.path, split.query, "/".join(sp)))
+                        print "trying", url, "field", field
                         if url in self.idx:
                             return url
                         sp.pop()

tests/test_examples.py

@@ -111,16 +111,20 @@ def test_scoped_ref(self):
         ldr.add_context({
             "scatter": {
                 "@type": "@id",
-                "scopedRef": True,
+                "refScope": 0,
             },
             "source": {
                 "@type": "@id",
-                "scopedRef": True,
+                "refScope": 2,
             },
             "in": {
                 "mapSubject": "id",
                 "mapPredicate": "source"
             },
+            "out": {
+                "@type": "@id",
+                "identity": True
+            },
             "inputs": {
                 "mapSubject": "id",
                 "mapPredicate": "type"
@@ -137,23 +141,40 @@ def test_scoped_ref(self):
             "steps": {
                 "step1": {
                     "in": {
-                        "echo_in": "inp"
+                        "inp": "inp"
+                    },
+                    "out": ["out"],
+                    "scatter": "inp"
+                },
+                "step2": {
+                    "in": {
+                        "inp": "step1/out"
                     },
-                    "scatter": "echo_in"
+                    "scatter": "inp"
                 }
             }
         }, "http://example2.com/")
 
+        print yaml.dump(ra)
+
         self.assertEquals({'inputs': [{
                 'id': 'http://example2.com/#inp',
                 'type': 'string'
             }],
             'steps': [{
                     'id': 'http://example2.com/#step1',
-                    'scatter': 'http://example2.com/#step1/echo_in',
+                    'scatter': 'http://example2.com/#step1/inp',
                     'in': [{
-                            'id': 'http://example2.com/#step1/echo_in',
+                            'id': 'http://example2.com/#step1/inp',
                             'source': 'http://example2.com/#inp'
+                    }],
+                    "out": ["http://example2.com/#step1/out"],
+            }, {
+                    'id': 'http://example2.com/#step2',
+                    'scatter': 'http://example2.com/#step2/inp',
+                    'in': [{
+                            'id': 'http://example2.com/#step2/inp',
+                            'source': 'http://example2.com/#step1/out'
                     }]
                 }]
         }, ra)