RDF 1.2 Triple Terms.

Author: gkellogg

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.0', 3.1, 3.2, 3.3, ruby-head, jruby]
+        ruby: ['3.0', 3.1, 3.2, 3.3, 3.4, ruby-head, jruby]
     steps:
       - name: Clone repository
         uses: actions/checkout@v3
@@ -33,7 +33,7 @@ jobs:
         run: ruby --version; bundle exec rspec spec || $ALLOW_FAILURES
       - name: Coveralls GitHub Action
         uses: coverallsapp/github-action@v2
-        if: "matrix.ruby == '3.2'"
+        if: "matrix.ruby == '3.4'"
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
   wintests:
@@ -42,11 +42,11 @@ jobs:
     runs-on: windows-latest
     env:
       CI: true
-      ALLOW_FAILURES: ${{ matrix.ruby == '3.2' || matrix.ruby == 'jruby' }}
+      ALLOW_FAILURES: ${{ matrix.ruby == 'jruby' }}
     strategy:
       fail-fast: false
       matrix:
-        ruby: [3.1, 3.2]
+        ruby: [3.1, 3.2, 3.3, 3.4]
     steps:
       - name: Clone repository
         uses: actions/checkout@v3

Gemfile

@@ -20,6 +20,8 @@ end
 group :development, :test do
   gem 'benchmark-ips'
   gem 'fasterer'
+  gem 'readline'
+  gem 'irb'
   gem 'psych', platforms: %i[mri rbx]
   gem 'rake'
   gem 'rubocop'

README.md

@@ -41,20 +41,70 @@ The [MultiJson](https://rubygems.org/gems/multi_json) gem is used for parsing an
 
 The {JSON::LD::API.expand}, {JSON::LD::API.compact}, {JSON::LD::API.toRdf}, and {JSON::LD::API.fromRdf} API methods, along with the {JSON::LD::Reader} and {JSON::LD::Writer}, include provisional support for [JSON-LD-star][JSON-LD-star].
 
-Internally, an `RDF::Statement` is treated as another resource, along with `RDF::URI` and `RDF::Node`, which allows an `RDF::Statement` to have a `#subject` or `#object` which is also an `RDF::Statement`.
+Internally, an `RDF::Statement` is treated as another resource, along with `RDF::URI` and `RDF::Node`, which allows an `RDF::Statement` to have an `#object` which is also an `RDF::Statement`.
 
-In JSON-LD, with the `rdfstar` option set, the value of `@id`, in addition to an IRI or Blank Node Identifier, can be a JSON-LD node object having exactly one property with an optional `@id`, which may also be an embedded object. (It may also have `@context` and `@index` values).
+#### Triple Terms
+
+In JSON-LD, with the `rdfstar` option set, a node object have an `@triple` property (or alias)  instead of `@id`, identifies the value of `@triple` as a [Triple Term](https://www.w3.org/TR/rdf12-concepts/#dfn-triple-term). The constraint on the value of `@triple` can be a JSON-LD node object having exactly one property with an optional `@id`, which may also be an triple term. (It may also have `@context` and `@index` values).
 
     {
-      "@id": {
+      "@triple": {
         "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
         "@index": "ignored",
         "@id": "bob",
         "foaf:age" 23
+      }
+    }
+
+The equivalent turtle would be the following:
+
+    <<( :bob <http://xmlns.com/foaf/0.1/age> 21 )>>
+
+An object including `@triple` **MUST NOT** define any extra properties for which that triple term would be used as the subject.
+
+#### Reifying Triples
+
+As RDF-star prefers the use of [reifiers](https://www.w3.org/TR/rdf12-concepts/#dfn-reifier) as a way to use a triple term. In this case the property `@refies` (or alias)  defines one (or more) triples which are _reified_ by the subject of the containing _node object_. The interpretation of a node object including `@reifies` creates a triple term for the triple(s) defined by the content of the block. The subject of that node object (`@id` or a default blank node) becomes the _reifier_ of the associated triple term(s).
+
+    {
+      "@context": {"foaf": "http://xmlns.com/foaf/0.1/", "ex": "http://example.com/"},
+      "@id": "_:reif",
+      "@reifies": {
+        "@id": "bob",
+        "foaf:age" 23
+      },
+      "ex:certainty": 0.9
+    }
+
+This is equivalent to the following JSON-LD using `@triple`:
+
+    {
+      "@context": {
+        "foaf": "http://xmlns.com/foaf/0.1/",
+        "ex": "http://example.com/",
+        "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
       },
+      "@id": "_:reif",
+      "rdf:reifies": {
+        "@triple": {
+          "@id": "bob",
+          "foaf:age" 23
+        }
+      }
       "ex:certainty": 0.9
     }
 
+Or, in Turtle:
+
+    _:reif rdf:reifies <<( :bob <http://xmlns.com/foaf/0.1/age> 21 )>>;
+           ex:certainty 0.9 .
+
+Or, equivalently, using the Turtle [`reifiedTriple`](https://www.w3.org/TR/rdf12-turtle/#grammar-production-reifiedTriple) syntax:
+
+    << :bob <http://xmlns.com/foaf/0.1/age> 21 ~ _:reif>> ex:certainty 0.9 .
+
+#### Annotation
+
 Additionally, the `@annotation` property (or alias) may be used on a node object or value object to annotate the statement for which the associated node is the object of a triple.
 
     {
@@ -66,42 +116,46 @@ Additionally, the `@annotation` property (or alias) may be used on a node object
       }
     }
 
-In the first case, the embedded node is not asserted, and only appears as the subject of a triple. In the second case, the triple is asserted and used as the subject in another statement which annotates it.
+In the case of Reifying Triples, the embedded triple term is not asserted, and only appears as the subject of a triple. In the second case, the triple is asserted and used as the subject in another statement which annotates it.
 
 **Note: This feature is subject to change or elimination as the standards process progresses.**
 
-#### Serializing a Graph containing embedded statements
+#### Serializing a Graph containing triple terms
 
     require 'json/ld'
-    statement = RDF::Statement(RDF::URI('bob'), RDF::Vocab::FOAF.age, RDF::Literal(23))
-    graph = RDF::Graph.new << [statement, RDF::URI("ex:certainty"), RDF::Literal(0.9)]
+    statement = RDF::Statement(RDF::URI('bob'), RDF::Vocab::FOAF.age, RDF::Literal(23), tripleTerm: true)
+    reif = RDF::Node.new("reif")
+    graph = RDF::Graph.new do |g|
+      g << [reif, RDF.reifies, statement]
+      g << [reif, RDF::URI("ex:certainty"), RDF::Literal(0.9)]
+    end
     graph.dump(:jsonld, validate: false, standard_prefixes: true)
-    # => {"@id": {"@id": "bob", "foaf:age" 23}, "ex:certainty": 0.9}
+    # => {"@id": "_:reif", @reifies: {"@id": "bob", "foaf:age" 23}, "ex:certainty": 0.9}
 
 Alternatively, using the {JSON::LD::API.fromRdf} method:
 
     JSON::LD::API::fromRdf(graph)
-    # => {"@id": {"@id": "bob", "foaf:age" 23}, "ex:certainty": 0.9}
+    # => {"@id": "_:reif", @reifies: {"@id": "bob", "foaf:age" 23}, "ex:certainty": 0.9}
 
-#### Reading a Graph containing embedded statements
+#### Reading a Graph containing triple terms
 
-By default, {JSON::LD::API.toRdf} (and {JSON::LD::Reader}) will reject a document containing a subject resource.
+By default, {JSON::LD::API.toRdf} (and {JSON::LD::Reader}) will reject a document containing a triple term.
 
     jsonld = %({
-      "@id": {
+      "@reifies": {
         "@id": "bob", "foaf:age" 23
       },
       "ex:certainty": 0.9
     })
     graph = RDF::Graph.new << JSON::LD::API.toRdf(input)
-    # => JSON::LD::JsonLdError::InvalidIdValue
+    # => JSON::LD::JsonLdError::InvalidReifier
 
 {JSON::LD::API.toRdf} (and {JSON::LD::Reader}) support a boolean valued `rdfstar` option; only one statement is asserted, although the reified statement is contained within the graph.
 
     graph = RDF::Graph.new do |graph|
       JSON::LD::Reader.new(jsonld, rdfstar: true) {|reader| graph << reader}
     end
-    graph.count #=> 1
+    graph.count #=> 3
 
 ## Examples
 

lib/json/ld.rb

@@ -73,9 +73,11 @@ module LD
                          @propagate
                          @protected
                          @preserve
+                         @reifier
                          @requireAll
                          @reverse
                          @set
+                         @triple
                          @type
                          @value
                          @version
@@ -128,6 +130,7 @@ class CollidingKeywords < JsonLdError; @code = 'colliding keywords'; end
       class ConflictingIndexes < JsonLdError; @code = 'conflicting indexes'; end
       class CyclicIRIMapping < JsonLdError; @code = 'cyclic IRI mapping'; end
       class InvalidAnnotation < JsonLdError; @code = 'invalid annotation'; end
+      class InvalidBaseDirection < JsonLdError; @code = 'invalid base direction'; end
       class InvalidBaseIRI < JsonLdError; @code = 'invalid base IRI'; end
       class InvalidContainerMapping < JsonLdError; @code = 'invalid container mapping'; end
       class InvalidContextEntry < JsonLdError; @code = 'invalid context entry'; end
@@ -149,7 +152,6 @@ class InvalidLocalContext < JsonLdError; @code = 'invalid local context'; end
       class InvalidNestValue < JsonLdError; @code = 'invalid @nest value'; end
       class InvalidPrefixValue < JsonLdError; @code = 'invalid @prefix value'; end
       class InvalidPropagateValue < JsonLdError; @code = 'invalid @propagate value'; end
-      class InvalidEmbeddedNode < JsonLdError; @code = 'invalid embedded node'; end
       class InvalidRemoteContext < JsonLdError; @code = 'invalid remote context'; end
       class InvalidReverseProperty < JsonLdError; @code = 'invalid reverse property'; end
       class InvalidReversePropertyMap < JsonLdError; @code = 'invalid reverse property map'; end
@@ -160,7 +162,7 @@ class InvalidScriptElement < JsonLdError; @code = 'invalid script element'; end
       class InvalidSetOrListObject < JsonLdError; @code = 'invalid set or list object'; end
       class InvalidStreamingKeyOrder < JsonLdError; @code = 'invalid streaming key order' end
       class InvalidTermDefinition < JsonLdError; @code = 'invalid term definition'; end
-      class InvalidBaseDirection < JsonLdError; @code = 'invalid base direction'; end
+      class InvalidTripleTerm < JsonLdError; @code = 'invalid triple term'; end
       class InvalidTypedValue < JsonLdError; @code = 'invalid typed value'; end
       class InvalidTypeMapping < JsonLdError; @code = 'invalid type mapping'; end
       class InvalidTypeValue < JsonLdError; @code = 'invalid type value'; end

lib/json/ld/compact.rb

@@ -22,7 +22,7 @@ def compact(element,
                   base: nil,
                   property: nil,
                   log_depth: nil)
-        # log_debug("compact", depth: log_depth.to_i) {"element: #{element.inspect}, ec: #{context.inspect}"}
+        log_debug("compact", depth: log_depth.to_i) {"element: #{element.inspect}, ec: #{context.inspect}"}
 
         # If the term definition for active property itself contains a context, use that for compacting values.
         input_context = context
@@ -101,14 +101,7 @@ def compact(element,
 
             if expanded_property == '@id'
               compacted_value = as_array(expanded_value).map do |expanded_id|
-                if node?(expanded_id) && @options[:rdfstar]
-                  # This can only really happen for valid RDF-star
-                  compact(expanded_id, base: base,
-                    property: '@id',
-                    log_depth: log_depth.to_i + 1)
-                else
-                  context.compact_iri(expanded_id, base: @options[:base])
-                end
+                context.compact_iri(expanded_id, base: @options[:base])
               end
 
               kw_alias = context.compact_iri('@id', vocab: true)
@@ -170,6 +163,18 @@ def compact(element,
               next
             end
 
+            # If expanded property is @triple
+            if expanded_property == '@triple'
+              # Compact using `property`
+              compacted_value = compact(expanded_value, base: base,
+                property: property,
+                log_depth: log_depth.to_i + 1)
+
+              al = context.compact_iri('@triple', vocab: true)
+              result[al] = compacted_value
+              next
+            end
+
             # Otherwise, if expanded property is @direction, @index, @value, or @language:
             if EXPANDED_PROPERTY_DIRECTION_INDEX_LANGUAGE_VALUE.include?(expanded_property)
               al = context.compact_iri(expanded_property, vocab: true)