Have toRdf emit only valid triples, excluding anything invalid. Literal validity is based on the value being a string, language having the proper form, and datatype IRI being valid.

Author: gkellogg

lib/json/ld/api.rb

@@ -455,19 +455,9 @@ def self.toRdf(input, expanded: false, **options, &block)
           item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
 
-            # Drop results with relative IRIs
-            relative = statement.to_a.any? do |r|
-              case r
-              when RDF::URI
-                r.relative?
-              when RDF::Literal
-                r.has_datatype? && r.datatype.relative?
-              else
-                false
-              end
-            end
-            if relative
-              log_debug(".toRdf") {"drop statement with relative IRIs: #{statement.to_ntriples}"}
+            # Drop invalid statements (other than IRIs)
+            unless statement.valid_extended?
+              log_debug(".toRdf") {"drop invalid statement: #{statement.to_nquads}"}
               next
             end
 

lib/json/ld/extensions.rb

@@ -7,6 +7,39 @@ def +(value)
       Node.new(id + value.to_s)
     end
   end
+
+  class Statement
+    # Validate extended RDF
+    def valid_extended?
+      has_subject?    && subject.resource? && subject.valid_extended? &&
+      has_predicate?  && predicate.resource? && predicate.valid_extended? &&
+      has_object?     && object.term? && object.valid_extended? &&
+      (has_graph?      ? (graph_name.resource? && graph_name.valid_extended?) : true)
+    end
+  end
+
+  class URI 
+    # Validate extended RDF
+    def valid_extended?
+      self.valid?
+    end
+  end
+
+  class Node 
+    # Validate extended RDF
+    def valid_extended?
+      self.valid?
+    end
+  end
+
+  class Literal 
+    # Validate extended RDF
+    def valid_extended?
+      return false if language? && language.to_s !~ /^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/
+      return false if datatype? && datatype.invalid?
+      value.is_a?(String)
+    end
+  end
 end
 
 class Array

spec/to_rdf_spec.rb

@@ -667,14 +667,70 @@
           %q(
             [<http://rdfs.org/sioc/ns#content> "foo"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>] .
           )
-        ]
+        ],
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
           expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
+
+    context "exceptions" do
+      {
+        "Invalid subject" => {
+          input: %({
+            "@id": "http://example.com/a b",
+            "http://example.com/foo": "bar"
+          }),
+          output: %()
+        },
+        "Invalid predicate" => {
+          input: %({
+            "@id": "http://example.com/foo",
+            "http://example.com/a b": "bar"
+          }),
+          output: %()
+        },
+        "Invalid object" => {
+          input: %({
+            "@id": "http://example.com/foo",
+            "http://example.com/bar": {"@id": "http://example.com/baz z"}
+          }),
+          output: %()
+        },
+        "Invalid type" => {
+          input: %({
+            "@id": "http://example.com/foo",
+            "@type": ["http://example.com/bar", "relative"]
+          }),
+          output: %(<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.com/bar> .)
+        },
+        "Invalid language" => {
+          input: %({
+            "@id": "http://example.com/foo",
+            "http://example.com/bar": {"@value": "bar", "@language": "a b"}
+          }),
+          output: %()
+        },
+        "Invalid datatype" => {
+          input: %({
+            "@id": "http://example.com/foo",
+            "http://example.com/bar": {"@value": "bar", "@type": "http://example.com/baz z"}
+          }),
+          output: %()
+        },
+        "Injected IRIs check" => {
+          input: %({
+            "@id": "http://foo/> <http://bar/> <http://baz> .\n<data:little> <data:bobby> <data:tables> .\n<data:in-ur-base",
+            "http://killin/#yer": "dudes"
+          }),
+          output: %()
+        },
+      }.each do |title, params|
+        it(title) {run_to_rdf params}
+      end
+    end
   end
 
   def parse(input, options = {})
@@ -683,4 +739,17 @@ def parse(input, options = {})
     JSON::LD::API.toRdf(StringIO.new(input), options) {|st| graph << st}
     graph
   end
+
+  def run_to_rdf(params)
+    input, output, processingMode = params[:input], params[:output], params[:processingMode]
+    graph = params[:graph] || RDF::Graph.new
+    input = StringIO.new(input) if input.is_a?(String)
+    pending params.fetch(:pending, "test implementation") unless input
+    if params[:exception]
+      expect {JSON::LD::API.toRdf(input, {processingMode: processingMode}.merge(params))}.to raise_error(params[:exception])
+    else
+      JSON::LD::API.toRdf(input, base: params[:base], logger: logger, processingMode: processingMode) {|st| graph << st}
+      expect(graph).to be_equivalent_graph(output, logger: logger, inputDocument: input)
+    end
+  end
 end