From 410e856cbf8a4fc05d39163f7fe138df400d5c2c Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 12 May 2026 11:23:08 +0200 Subject: [PATCH 01/11] Add regression test for scoped context in a @nest attribute. --- tests/test_jsonld.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/tests/test_jsonld.py b/tests/test_jsonld.py index f7b00217..6543e6af 100644 --- a/tests/test_jsonld.py +++ b/tests/test_jsonld.py @@ -316,6 +316,34 @@ def test_structured_value_still_works_with_scoped_context(self): # meaning -> @id assert "@id" in prop_val + # Issue 204 + def test_scoped_context_on_nest_term_expands_nested_properties(self): + """A scoped context on a @nest term should apply to nested properties.""" + input = { + "@context": { + "@vocab": "http://example.org/vocab#", + "p1": { + "@id": "@nest", + "@context": {"p2": "http://example.org/ns#P2"}, + }, + }, + "p1": {"p2": "foo"}, + } + + expected = [ + { + "http://example.org/ns#P2": [ + { + "@value": "foo", + } + ], + } + ] + + result = jsonld.expand(input) + + assert result == expected + def test_mixed_plain_and_vocab_terms(self): """Contexts with both plain and @type:@vocab terms should work correctly.""" From 1ab18a8c7cbe62168643017adad5a4f242304024 Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 12 May 2026 11:45:27 +0200 Subject: [PATCH 02/11] Use the scoped @context from the @nest term for expansion. --- lib/pyld/jsonld.py | 18 +++++++++--------- tests/runtests.py | 2 -- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/lib/pyld/jsonld.py b/lib/pyld/jsonld.py index 94899b40..59dd887d 100644 --- a/lib/pyld/jsonld.py +++ b/lib/pyld/jsonld.py @@ -2620,11 +2620,6 @@ def _expand_object( continue - # nested keys - if expanded_property == '@nest': - nests.append(key) - continue - # use potential scoped context for key term_ctx = active_ctx ctx = JsonLdProcessor.get_context_value(active_ctx, key, '@context') @@ -2633,6 +2628,11 @@ def _expand_object( active_ctx, ctx, options, propagate=True, override_protected=True ) + # for nested keys, add scoped context with key + if expanded_property == '@nest': + nests.append((key, term_ctx)) + continue + container = JsonLdProcessor.arrayify( JsonLdProcessor.get_context_value(active_ctx, key, '@container') ) @@ -2775,13 +2775,13 @@ def _expand_object( code='invalid value object value', ) - # expand each nested key - for key in nests: + # expand each nested key and scoped context + for key, term_ctx in nests: for nv in JsonLdProcessor.arrayify(element[key]): if not _is_object(nv) or [ k for k, v in nv.items() - if self._expand_iri(active_ctx, k, vocab=True) == '@value' + if self._expand_iri(term_ctx, k, vocab=True) == '@value' ]: raise JsonLdError( 'Invalid JSON-LD syntax; nested value must be a node object.', @@ -2790,7 +2790,7 @@ def _expand_object( code='invalid @nest value', ) self._expand_object( - active_ctx, + term_ctx, active_property, expanded_active_property, nv, diff --git a/tests/runtests.py b/tests/runtests.py index dd82b314..b9f7f97d 100644 --- a/tests/runtests.py +++ b/tests/runtests.py @@ -1019,12 +1019,10 @@ def write(self, filename): # well formed '.*toRdf-manifest#twf05$', # uncategorized - '.*toRdf-manifest#tc038$', '.*toRdf-manifest#ter54$', '.*toRdf-manifest#ter56$', '.*toRdf-manifest#tli12$', '.*toRdf-manifest#tli14$', - '.*toRdf-manifest#tc037$', ] }, 'skip': { From 06b5e3a081dfee980c447e7f6c5fac567b3fc4cd Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 12 May 2026 11:59:53 +0200 Subject: [PATCH 03/11] Add to_rdf tests on conflicting property names in local context --- tests/test_to_rdf.py | 55 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 tests/test_to_rdf.py diff --git a/tests/test_to_rdf.py b/tests/test_to_rdf.py new file mode 100644 index 00000000..06e10a1e --- /dev/null +++ b/tests/test_to_rdf.py @@ -0,0 +1,55 @@ +from pyld import jsonld + +# Issue 204 +def test_conflicting_property_names(): + """ + Conversion to RDF should allow a node in the root @context with + a conflicting property name in its own @context + """ + input = { + "@context": { + "dublinCore": { + "@id": "http://foo.bar/dc", + "@context": {"title": "http://purl.org/dc/terms/title"}, + }, + "title": "http://foo.bar/title", + }, + "@id": "http://foo.bar/obj/test", + "title": "test", + "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, + } + + expected = """ _:b0 . + "test" . +_:b0 "Chapter 1: Jonathan Harker's Journal" . +""" + + nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) + assert nquads == expected + + +def test_conflicting_property_names_in_nested_node(): + """ + Conversion to RDF should not ignore a @nest'ed node in the root @context + a conflicting property name in its own @context + """ + input = { + "@context": { + "dublinCore": { + "@id": "@nest", + "@context": {"title": "http://purl.org/dc/terms/title"}, + }, + "title": "http://foo.bar/title", + }, + "@id": "http://foo.bar/obj/test", + "title": "test", + "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, + } + + expected = """ _:b0 . + "test" . +_:b0 "Chapter 1: Jonathan Harker's Journal" . +""" + + nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) + assert nquads == expected From 53ca355060230ea773250e450c07643b94a32d97 Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 12 May 2026 21:24:03 +0200 Subject: [PATCH 04/11] Correct expected output in test --- tests/test_to_rdf.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/test_to_rdf.py b/tests/test_to_rdf.py index 06e10a1e..b60e2ca6 100644 --- a/tests/test_to_rdf.py +++ b/tests/test_to_rdf.py @@ -46,9 +46,8 @@ def test_conflicting_property_names_in_nested_node(): "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, } - expected = """ _:b0 . - "test" . -_:b0 "Chapter 1: Jonathan Harker's Journal" . + expected = """ "test" . + "Chapter 1: Jonathan Harker's Journal" . """ nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) From e952c8bff52bad5e83939515052fe6f421d060fe Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 12 May 2026 21:26:08 +0200 Subject: [PATCH 05/11] Satisfy linter --- tests/test_to_rdf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_to_rdf.py b/tests/test_to_rdf.py index b60e2ca6..f5a0202b 100644 --- a/tests/test_to_rdf.py +++ b/tests/test_to_rdf.py @@ -1,5 +1,6 @@ from pyld import jsonld + # Issue 204 def test_conflicting_property_names(): """ From 7fd967314b8ff025174d9ff6e085651e8707309d Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Wed, 13 May 2026 12:09:56 +0200 Subject: [PATCH 06/11] Move toRdf tests into test_jsonld for now. --- tests/test_jsonld.py | 53 ++++++++++++++++++++++++++++++++++++++++++ tests/test_to_rdf.py | 55 -------------------------------------------- 2 files changed, 53 insertions(+), 55 deletions(-) delete mode 100644 tests/test_to_rdf.py diff --git a/tests/test_jsonld.py b/tests/test_jsonld.py index 6543e6af..a86f366d 100644 --- a/tests/test_jsonld.py +++ b/tests/test_jsonld.py @@ -780,6 +780,59 @@ def test_double_and_float_values(self): result = jsonld.to_rdf(input) assert result == expected + # Issue 204 + def test_conflicting_property_names(self): + """ + Conversion to RDF should allow a node in the root @context with + a conflicting property name in its own @context + """ + input = { + "@context": { + "dublinCore": { + "@id": "http://foo.bar/dc", + "@context": {"title": "http://purl.org/dc/terms/title"}, + }, + "title": "http://foo.bar/title", + }, + "@id": "http://foo.bar/obj/test", + "title": "test", + "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, + } + + expected = """ _:b0 . + "test" . +_:b0 "Chapter 1: Jonathan Harker's Journal" . +""" + + nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) + assert nquads == expected + + + def test_conflicting_property_names_in_nested_node(self): + """ + Conversion to RDF should not ignore a @nest'ed node in the root @context + a conflicting property name in its own @context + """ + input = { + "@context": { + "dublinCore": { + "@id": "@nest", + "@context": {"title": "http://purl.org/dc/terms/title"}, + }, + "title": "http://foo.bar/title", + }, + "@id": "http://foo.bar/obj/test", + "title": "test", + "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, + } + + expected = """ "test" . + "Chapter 1: Jonathan Harker's Journal" . +""" + + nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) + assert nquads == expected + class TestCompact: # Issue 59 - PR: https://github.com/digitalbazaar/pyld/pull/60 diff --git a/tests/test_to_rdf.py b/tests/test_to_rdf.py deleted file mode 100644 index f5a0202b..00000000 --- a/tests/test_to_rdf.py +++ /dev/null @@ -1,55 +0,0 @@ -from pyld import jsonld - - -# Issue 204 -def test_conflicting_property_names(): - """ - Conversion to RDF should allow a node in the root @context with - a conflicting property name in its own @context - """ - input = { - "@context": { - "dublinCore": { - "@id": "http://foo.bar/dc", - "@context": {"title": "http://purl.org/dc/terms/title"}, - }, - "title": "http://foo.bar/title", - }, - "@id": "http://foo.bar/obj/test", - "title": "test", - "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, - } - - expected = """ _:b0 . - "test" . -_:b0 "Chapter 1: Jonathan Harker's Journal" . -""" - - nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) - assert nquads == expected - - -def test_conflicting_property_names_in_nested_node(): - """ - Conversion to RDF should not ignore a @nest'ed node in the root @context - a conflicting property name in its own @context - """ - input = { - "@context": { - "dublinCore": { - "@id": "@nest", - "@context": {"title": "http://purl.org/dc/terms/title"}, - }, - "title": "http://foo.bar/title", - }, - "@id": "http://foo.bar/obj/test", - "title": "test", - "dublinCore": {"title": "Chapter 1: Jonathan Harker's Journal"}, - } - - expected = """ "test" . - "Chapter 1: Jonathan Harker's Journal" . -""" - - nquads = jsonld.to_rdf(input, options={'format': 'application/n-quads'}) - assert nquads == expected From 00d034cd207568f0e6a078398a1001a3b6d318fa Mon Sep 17 00:00:00 2001 From: Anatoly Scherbakov Date: Thu, 14 May 2026 14:39:15 +0200 Subject: [PATCH 07/11] [#204]: Add nested type-scoped context regression test --- tests/test_jsonld.py | 60 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/tests/test_jsonld.py b/tests/test_jsonld.py index a86f366d..53348fd3 100644 --- a/tests/test_jsonld.py +++ b/tests/test_jsonld.py @@ -344,6 +344,66 @@ def test_scoped_context_on_nest_term_expands_nested_properties(self): assert result == expected + # Issue 204 + def test_scoped_context_on_nest_term_expands_nested_type_scoped_context(self): + """ + A scoped context on a @nest term should be in effect when expanding the + nested node, including when processing any type-scoped contexts found on + that node. + + JSON-LD 1.1 defines property nesting as semantically transparent: nested + properties are removed during expansion and treated as if their contents + were declared directly on the containing node object. It also defines + scoped contexts as property-scoped when the term is used as a property + and type-scoped when the term is used as a type. This test combines both + rules deliberately: + + * p1 is an @nest term with a property-scoped context. + * That context defines Type and gives Type its own type-scoped context. + * The nested node uses Type and then uses p2 from Type's scoped context. + + If nested values are expanded by directly walking their keys instead of + running the normal expansion setup for the nested node, Type and p2 fall + back to the outer @vocab. The expected result proves that the @nest term + context is active before @type is expanded and before Type's scoped + context is applied. + """ + input = { + "@context": { + "@vocab": "http://example.org/outer#", + "p1": { + "@id": "@nest", + "@context": { + "Type": { + "@id": "http://example.org/ns#Type", + "@context": { + "p2": "http://example.org/ns#P2", + }, + }, + }, + }, + }, + "p1": { + "@type": "Type", + "p2": "foo", + }, + } + + expected = [ + { + "@type": ["http://example.org/ns#Type"], + "http://example.org/ns#P2": [ + { + "@value": "foo", + } + ], + } + ] + + result = jsonld.expand(input) + + assert result == expected + def test_mixed_plain_and_vocab_terms(self): """Contexts with both plain and @type:@vocab terms should work correctly.""" From 60a935ab62826725336a21892c5022ec6bcd8294 Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Mon, 18 May 2026 11:27:48 +0200 Subject: [PATCH 08/11] Fix complex property nesting in scoped contexts by preparing local and type-scoped contexts first for a nested node object. --- lib/pyld/jsonld.py | 67 ++++++++++++++++++++++++++++++++++++++++---- tests/test_jsonld.py | 25 ++++++----------- 2 files changed, 69 insertions(+), 23 deletions(-) diff --git a/lib/pyld/jsonld.py b/lib/pyld/jsonld.py index 59dd887d..7cf72511 100644 --- a/lib/pyld/jsonld.py +++ b/lib/pyld/jsonld.py @@ -2775,13 +2775,26 @@ def _expand_object( code='invalid value object value', ) - # expand each nested key and scoped context + # Nested values merge into the current node, but their term and type + # scoped contexts must still be prepared as if expanding a node object. for key, term_ctx in nests: for nv in JsonLdProcessor.arrayify(element[key]): - if not _is_object(nv) or [ + if not _is_object(nv): + raise JsonLdError( + 'Invalid JSON-LD syntax; nested value must be a node object.', + 'jsonld.SyntaxError', + {'value': nv}, + code='invalid @nest value', + ) + + nested_active_ctx, nested_type_key, nested_type_scoped_ctx = ( + self._prepare_nested_context(term_ctx, nv, options) + ) + + if [ k for k, v in nv.items() - if self._expand_iri(term_ctx, k, vocab=True) == '@value' + if self._expand_iri(nested_active_ctx, k, vocab=True) == '@value' ]: raise JsonLdError( 'Invalid JSON-LD syntax; nested value must be a node object.', @@ -2789,17 +2802,59 @@ def _expand_object( {'value': nv}, code='invalid @nest value', ) + self._expand_object( - term_ctx, + nested_active_ctx, active_property, expanded_active_property, nv, expanded_parent, options, inside_list=inside_list, - type_key=type_key, - type_scoped_ctx=type_scoped_ctx, + type_key=nested_type_key, + type_scoped_ctx=nested_type_scoped_ctx, + ) + + def _prepare_nested_context(self, active_ctx, element, options): + """ + Prepare local and type-scoped contexts for a nested node object. + + `@nest` is semantically transparent in JSON-LD 1.1, so nested properties + are merged into the parent node. Context processing is not transparent: + a scoped context on the nest term must be active while discovering any + @type entries and applying the type-scoped contexts they reference. + """ + # Local contexts on the nested node apply before looking for @type, + # just like they do for an ordinary node object. + if '@context' in element: + active_ctx = self._process_context( + active_ctx, element['@context'], options + ) + + # Type terms are looked up against the context that was active before + # applying any type-scoped contexts discovered below. + type_scoped_ctx = active_ctx + type_key = None + for key, value in sorted(element.items()): + # The @type entry itself may be aliased by the nest term's scoped + # context, so use the nested active context to identify it. + if self._expand_iri(active_ctx, key, vocab=True) != '@type': + continue + + type_key = type_key or key + types = [t for t in JsonLdProcessor.arrayify(value) if _is_string(t)] + for type_ in sorted(types): + ctx = JsonLdProcessor.get_context_value( + type_scoped_ctx, type_, '@context' ) + if ctx is not None and ctx is not False: + # Type-scoped contexts affect expansion of this nested node, + # but must not leak into sibling properties or parent nodes. + active_ctx = self._process_context( + active_ctx, ctx, options, propagate=False + ) + + return active_ctx, type_key, type_scoped_ctx def _flatten(self, input): """ diff --git a/tests/test_jsonld.py b/tests/test_jsonld.py index 53348fd3..85458e4c 100644 --- a/tests/test_jsonld.py +++ b/tests/test_jsonld.py @@ -350,30 +350,16 @@ def test_scoped_context_on_nest_term_expands_nested_type_scoped_context(self): A scoped context on a @nest term should be in effect when expanding the nested node, including when processing any type-scoped contexts found on that node. - - JSON-LD 1.1 defines property nesting as semantically transparent: nested - properties are removed during expansion and treated as if their contents - were declared directly on the containing node object. It also defines - scoped contexts as property-scoped when the term is used as a property - and type-scoped when the term is used as a type. This test combines both - rules deliberately: - - * p1 is an @nest term with a property-scoped context. - * That context defines Type and gives Type its own type-scoped context. - * The nested node uses Type and then uses p2 from Type's scoped context. - - If nested values are expanded by directly walking their keys instead of - running the normal expansion setup for the nested node, Type and p2 fall - back to the outer @vocab. The expected result proves that the @nest term - context is active before @type is expanded and before Type's scoped - context is applied. """ input = { "@context": { "@vocab": "http://example.org/outer#", + # p1 is an @nest term with a property-scoped context. That context defines + # Type and gives Type its own type-scoped context. "p1": { "@id": "@nest", "@context": { + # The nested node uses Type and then uses p2 from Type's scoped context. "Type": { "@id": "http://example.org/ns#Type", "@context": { @@ -389,8 +375,13 @@ def test_scoped_context_on_nest_term_expands_nested_type_scoped_context(self): }, } + # The @nest term context is active before @type is expanded and before Type's scoped + # context is applied. expected = [ { + # If nested values are expanded by directly walking their keys instead of + # running the normal expansion setup for the nested node, Type and p2 fall + # back to the outer @vocab. "@type": ["http://example.org/ns#Type"], "http://example.org/ns#P2": [ { From 706dccc5c7f21c2d0211ae660a84c194cf8a7e36 Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Mon, 18 May 2026 12:16:13 +0200 Subject: [PATCH 09/11] Use _prepare_nested_context in _expand as well --- lib/pyld/jsonld.py | 47 +++++++++++++--------------------------------- 1 file changed, 13 insertions(+), 34 deletions(-) diff --git a/lib/pyld/jsonld.py b/lib/pyld/jsonld.py index 7cf72511..d42c63f2 100644 --- a/lib/pyld/jsonld.py +++ b/lib/pyld/jsonld.py @@ -2139,35 +2139,10 @@ def _expand( active_ctx, property_scoped_ctx, options, override_protected=True ) - # recursively expand object - # if element has a context, process it - if '@context' in element: - active_ctx = self._process_context(active_ctx, element['@context'], options) - - # set the type-scoped context to the context on input, for use later - type_scoped_ctx = active_ctx - - # Remember the first key found expanding to @type - type_key = None - - # look for scoped context on @type - for key, _value in sorted(element.items()): - expanded_property = self._expand_iri(active_ctx, key, vocab=True) - if expanded_property == '@type': - if not type_key: - type_key = key - # set scoped contexts from @type - types = [ - t for t in JsonLdProcessor.arrayify(element[key]) if _is_string(t) - ] - for type_ in sorted(types): - ctx = JsonLdProcessor.get_context_value( - type_scoped_ctx, type_, '@context' - ) - if ctx is not None and ctx is not False: - active_ctx = self._process_context( - active_ctx, ctx, options, propagate=False - ) + # prepare type-scoped contexts + active_ctx, type_key, type_scoped_ctx = self._prepare_nested_context( + active_ctx, element, options + ) # process each key and value in element, ignoring @nest content rval = {} @@ -2824,17 +2799,20 @@ def _prepare_nested_context(self, active_ctx, element, options): a scoped context on the nest term must be active while discovering any @type entries and applying the type-scoped contexts they reference. """ + # Recursively expand object: process context if element has one # Local contexts on the nested node apply before looking for @type, # just like they do for an ordinary node object. if '@context' in element: - active_ctx = self._process_context( - active_ctx, element['@context'], options - ) + active_ctx = self._process_context(active_ctx, element['@context'], options) - # Type terms are looked up against the context that was active before - # applying any type-scoped contexts discovered below. + # Set the type-scoped context to the context on input, for use later type_scoped_ctx = active_ctx + + # Remember the first key found expanding to @type type_key = None + + # Type terms are looked up against the context that was active before + # applying any type-scoped contexts discovered below. for key, value in sorted(element.items()): # The @type entry itself may be aliased by the nest term's scoped # context, so use the nested active context to identify it. @@ -2842,6 +2820,7 @@ def _prepare_nested_context(self, active_ctx, element, options): continue type_key = type_key or key + # set scoped contexts from @type types = [t for t in JsonLdProcessor.arrayify(value) if _is_string(t)] for type_ in sorted(types): ctx = JsonLdProcessor.get_context_value( From 3d42075359024f05e6a18b0d3f9b6040442cee1d Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 19 May 2026 06:43:03 +0200 Subject: [PATCH 10/11] Small cleanup to reduce changes --- lib/pyld/jsonld.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/lib/pyld/jsonld.py b/lib/pyld/jsonld.py index d42c63f2..0ef16bf6 100644 --- a/lib/pyld/jsonld.py +++ b/lib/pyld/jsonld.py @@ -2139,9 +2139,9 @@ def _expand( active_ctx, property_scoped_ctx, options, override_protected=True ) - # prepare type-scoped contexts - active_ctx, type_key, type_scoped_ctx = self._prepare_nested_context( - active_ctx, element, options + # prepare type-scoped contexts when nested + active_ctx, type_key, type_scoped_ctx = ( + self._prepare_nested_context(active_ctx, element, options) ) # process each key and value in element, ignoring @nest content @@ -2762,14 +2762,15 @@ def _expand_object( code='invalid @nest value', ) - nested_active_ctx, nested_type_key, nested_type_scoped_ctx = ( + # prepare type-scoped contexts when nested + active_ctx, type_key, type_scoped_ctx = ( self._prepare_nested_context(term_ctx, nv, options) ) if [ k for k, v in nv.items() - if self._expand_iri(nested_active_ctx, k, vocab=True) == '@value' + if self._expand_iri(active_ctx, k, vocab=True) == '@value' ]: raise JsonLdError( 'Invalid JSON-LD syntax; nested value must be a node object.', @@ -2779,15 +2780,15 @@ def _expand_object( ) self._expand_object( - nested_active_ctx, + active_ctx, active_property, expanded_active_property, nv, expanded_parent, options, inside_list=inside_list, - type_key=nested_type_key, - type_scoped_ctx=nested_type_scoped_ctx, + type_key=type_key, + type_scoped_ctx=type_scoped_ctx, ) def _prepare_nested_context(self, active_ctx, element, options): From 8ae0f29d25df6b4d1403a7561a7b42269903c95d Mon Sep 17 00:00:00 2001 From: Miel Vander Sande Date: Tue, 19 May 2026 07:15:50 +0200 Subject: [PATCH 11/11] Add to changelog. --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c5194f8..2a0e3010 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ - Options from the test manifest now override the options configured in `create_test_options()`, instead of the other way around. This fixes tests not able to override default options in the test-setup such as `extractAllScripts`. Fixes [html#tf004](https://w3c.github.io/json-ld-api/tests/html-manifest#tf004). - When `@type` is `@json` in a frame, it no longer raises an "Invalid JSON-LD syntax" error. Fixes [frame#t0069](https://w3c.github.io/json-ld-framing/tests/frame-manifest.html#t0069). - Use safeguard for non-dict values of `options['link']` +- Local and type-scoped contexts are now properly resolved for nested node objects, so a scoped context on a `@nest` term is being applied to nested properties. Fixes [toRdf#tc037](https://w3c.github.io/json-ld-api/tests/toRdf-manifest.html#tc037) and [toRdf#tc038](https://w3c.github.io/json-ld-api/tests/toRdf-manifest.html#tc038). ### Changed - `requests_document_loader()` and `aiohttp_document_loader()` now return