Separate RDF::Literal handling from Context#expand_value directly into FromRDF#resource_representation.

Author: gkellogg

lib/json/ld/context.rb

@@ -1467,8 +1467,6 @@ def compact_iri(iri, base: nil, reverse: false, value: nil, vocab: nil)
       end
     end
 
-    RDF_LITERAL_NATIVE_TYPES = Set.new([RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double]).freeze
-
     ##
     # If active property has a type mapping in the active context set to @id or @vocab, a JSON object with a single member @id whose value is the result of using the IRI Expansion algorithm on value is returned.
     #
@@ -1500,50 +1498,12 @@ def expand_value(property, value, useNativeTypes: false, rdfDirection: nil, base
         return {'@id' => expand_iri(value, vocab: true, documentRelative: true, base: base).to_s}
       end
 
-      value = RDF::Literal(value) if
-        value.is_a?(Date) ||
-        value.is_a?(DateTime) ||
-        value.is_a?(Time)
-
       result = case value
       when RDF::URI, RDF::Node
         {'@id' => value.to_s}
-      when RDF::Literal
-        res = {}
-        if value.datatype == RDF::URI(RDF.to_uri + "JSON") && processingMode('json-ld-1.1')
-          # Value parsed as JSON
-          # FIXME: MultiJson
-          res['@type'] = '@json'
-          res['@value'] = ::JSON.parse(value.object)
-        elsif value.datatype.start_with?("https://www.w3.org/ns/i18n#") && rdfDirection == 'i18n-datatype' && processingMode('json-ld-1.1')
-          lang, dir = value.datatype.fragment.split('_')
-          res['@value'] = value.to_s
-          unless lang.empty?
-            if lang !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
-              if options[:validate]
-                raise JsonLdError::InvalidLanguageMapping, "rdf:language must be valid BCP47: #{lang.inspect}"
-              else
-                warn "rdf:language must be valid BCP47: #{lang.inspect}"
-              end
-            end
-            res['@language'] = lang
-          end
-          res['@direction'] = dir
-        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype) && value.valid?
-          res['@type'] = uri(coerce(property)) if coerce(property)
-          res['@value'] = value.object
-        else
-          value.canonicalize! if value.valid? && value.datatype == RDF::XSD.double
-          if coerce(property)
-            res['@type'] = uri(coerce(property)).to_s
-          elsif value.datatype?
-            res['@type'] = uri(value.datatype).to_s
-          elsif value.language? || language(property)
-            res['@language'] = (value.language || language(property)).to_s
-          end
-          res['@value'] = value.to_s
-        end
-        res
+      when Date, DateTime, Time
+        lit = RDF::Literal.new(value)
+        {'@value' => lit.to_s, '@type' => lit.datatype.to_s}
       else
         # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
         res = {}
@@ -1561,8 +1521,6 @@ def expand_value(property, value, useNativeTypes: false, rdfDirection: nil, base
       end
 
       result
-    rescue ::JSON::ParserError => e
-      raise JSON::LD::JsonLdError::InvalidJsonLiteral, e.message
     end
 
     ##

lib/json/ld/from_rdf.rb

@@ -168,6 +168,9 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false)
     end
 
     private
+
+    RDF_LITERAL_NATIVE_TYPES = Set.new([RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double]).freeze
+
     def resource_representation(resource, useNativeTypes)
       case resource
       when RDF::Statement
@@ -183,11 +186,43 @@ def resource_representation(resource, useNativeTypes)
         end
         rep
       when RDF::Literal
-        @context.expand_value(nil,
-                              resource,
-                              rdfDirection: @options[:rdfDirection],
-                              useNativeTypes: useNativeTypes,
-                              base: @options[:base])
+        base = @options[:base]
+        rdfDirection = @options[:rdfDirection]
+        res = {}
+
+        if resource.datatype == RDF::URI(RDF.to_uri + "JSON") && @context.processingMode('json-ld-1.1')
+          res['@type'] = '@json'
+          res['@value'] = begin
+            ::JSON.parse(resource.object)
+          rescue ::JSON::ParserError => e
+            raise JSON::LD::JsonLdError::InvalidJsonLiteral, e.message
+          end
+        elsif resource.datatype.start_with?("https://www.w3.org/ns/i18n#") && rdfDirection == 'i18n-datatype' && @context.processingMode('json-ld-1.1')
+          lang, dir = resource.datatype.fragment.split('_')
+          res['@value'] = resource.to_s
+          unless lang.empty?
+            if lang !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+              if options[:validate]
+                raise JsonLdError::InvalidLanguageMapping, "rdf:language must be valid BCP47: #{lang.inspect}"
+              else
+                warn "rdf:language must be valid BCP47: #{lang.inspect}"
+              end
+            end
+            res['@language'] = lang
+          end
+          res['@direction'] = dir
+        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(resource.datatype) && resource.valid?
+          res['@value'] = resource.object
+        else
+          resource.canonicalize! if resource.valid? && resource.datatype == RDF::XSD.double
+          if resource.datatype?
+            res['@type'] = resource.datatype.to_s
+          elsif resource.language?
+            res['@language'] = resource.language.to_s
+          end
+          res['@value'] = resource.to_s
+        end
+        res
       else
         {'@id' => resource.to_s}
       end

spec/context_spec.rb

@@ -1553,14 +1553,6 @@ def containers
       "native double" =>  ["foo", 1.1e1,                          {"@value" => 1.1E1}],
       "native date" =>    ["foo", Date.parse("2011-12-27"),       {"@value" => "2011-12-27", "@type" => RDF::XSD.date.to_s}],
       "native dateTime" =>["foo", DateTime.parse("2011-12-27T10:11:12Z"), {"@value" => "2011-12-27T10:11:12Z", "@type" => RDF::XSD.dateTime.to_s}],
-      "rdf boolean" =>    ["foo", RDF::Literal(true),             {"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
-      "rdf integer" =>    ["foo", RDF::Literal(1),                {"@value" => "1", "@type" => RDF::XSD.integer.to_s}],
-      "rdf decimal" =>    ["foo", RDF::Literal::Decimal.new(1.1), {"@value" => "1.1", "@type" => RDF::XSD.decimal.to_s}],
-      "rdf double" =>     ["foo", RDF::Literal::Double.new(1.1),  {"@value" => "1.1E0", "@type" => RDF::XSD.double.to_s}],
-      "rdf URI" =>        ["foo", RDF::URI("foo"),                {"@id" => "foo"}],
-      "rdf date " =>      ["foo", RDF::Literal(Date.parse("2011-12-27")), {"@value" => "2011-12-27", "@type" => RDF::XSD.date.to_s}],
-      "rdf nonNeg" =>     ["foo", RDF::Literal::NonNegativeInteger.new(1), {"@value" => "1", "@type" => RDF::XSD.nonNegativeInteger}],
-      "rdf float" =>      ["foo", RDF::Literal::Float.new(1.0),   {"@value" => "1.0", "@type" => RDF::XSD.float}],
       "ex:none string" => ["ex:none", "foo",                      {"@value" => "foo"}],
       "ex:none boolean" =>["ex:none", true,                       {"@value" => true}],
       "ex:none integer" =>["ex:none", 1,                          {"@value" => 1}],