json-ld 3.2.3 → 3.2.4

data/lib/json/ld/expand.rb

@@ -29,13 +29,13 @@ module JSON::LD
     # @return [Array<Hash{String => Object}>]
     def expand(input, active_property, context,
                framing: false, from_map: false, log_depth: nil)
-      log_debug("expand", depth: log_depth.to_i) {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+      # log_debug("expand", depth: log_depth.to_i) {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       framing = false if active_property == '@default'
       expanded_active_property = context.expand_iri(active_property, vocab: true, as_string: true, base: @options[:base]) if active_property
 
       # Use a term-specific context, if defined, based on the non-type-scoped context.
       property_scoped_context = context.term_definitions[active_property].context if active_property && context.term_definitions[active_property]
-      log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{property_scoped_context.inspect}"} unless property_scoped_context.nil?
+      # log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{property_scoped_context.inspect}"} unless property_scoped_context.nil?
 
       result = case input
       when Array
@@ -76,7 +76,7 @@ module JSON::LD
             !(expanded_key_map.values == ['@id'])
 
           # If there's a previous context, the context was type-scoped
-          log_debug("expand", depth: log_depth.to_i) {"previous_context: #{context.previous_context.inspect}"} if revert_context
+          # log_debug("expand", depth: log_depth.to_i) {"previous_context: #{context.previous_context.inspect}"} if revert_context
           context = context.previous_context if revert_context
         end
 
@@ -84,12 +84,12 @@ module JSON::LD
         unless property_scoped_context.nil?
           context = context.parse(property_scoped_context, base: @options[:base], override_protected: true)
         end
-        log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
+        # log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
         if input.key?('@context')
           context = context.parse(input['@context'], base: @options[:base])
-          log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
+          # log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
         end
 
         # Set the type-scoped context to the context on input, for use later
@@ -107,7 +107,7 @@ module JSON::LD
           Array(input[tk]).sort.each do |term|
             term_context = type_scoped_context.term_definitions[term].context if type_scoped_context.term_definitions[term]
             unless term_context.nil?
-              log_debug("expand", depth: log_depth.to_i) {"term_context[#{term}]: #{term_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"term_context[#{term}]: #{term_context.inspect}"}
               context = context.parse(term_context, base: @options[:base], propagate: false)
             end
           end
@@ -121,7 +121,7 @@ module JSON::LD
                       type_scoped_context: type_scoped_context,
                       log_depth: log_depth.to_i + 1)
 
-        log_debug("output object", depth: log_depth.to_i) {output_object.inspect}
+        # log_debug("output object", depth: log_depth.to_i) {output_object.inspect}
 
         # If result contains the key @value:
         if value?(output_object)
@@ -199,7 +199,7 @@ module JSON::LD
         if (expanded_active_property || '@graph') == '@graph' &&
            (output_object.key?('@value') || output_object.key?('@list') ||
            (output_object.keys - KEY_ID).empty? && !framing)
-          log_debug(" =>", depth: log_depth.to_i) { "empty top-level: " + output_object.inspect}
+          # log_debug(" =>", depth: log_depth.to_i) { "empty top-level: " + output_object.inspect}
           return nil
         end
 
@@ -219,12 +219,12 @@ module JSON::LD
                                   base: @options[:base],
                                   override_protected: true)
         end
-        log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
+        # log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         context.expand_value(active_property, input, base: @options[:base])
       end
 
-      log_debug(depth: log_depth.to_i) {" => #{result.inspect}"}
+      # log_debug(depth: log_depth.to_i) {" => #{result.inspect}"}
       result
     end
 
@@ -258,10 +258,10 @@ module JSON::LD
           expanded_property.to_s.start_with?("_:") &&
           context.processingMode('json-ld-1.1')
 
-        log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+        # log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
         if expanded_property.nil?
-          log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
+          # log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
           next
         end
 
@@ -341,7 +341,7 @@ module JSON::LD
             Array(output_object['@included']) + included_result
           when '@type'
             # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
-            log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
+            # log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
             e_type = case value
             when Array
               value.map do |v|
@@ -516,7 +516,7 @@ module JSON::LD
 
             # If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
             if value.key?('@reverse')
-              log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
+              # log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
               value['@reverse'].each do |property, item|
                 # If result does not have a property member, create one and set its value to an empty array.
                 # Append item to the value of the property member of result.
@@ -566,7 +566,7 @@ module JSON::LD
           end
 
           # Unless expanded value is null, set the expanded property member of result to expanded value.
-          log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
+          # log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
           output_object[expanded_property] = expanded_value unless expanded_value.nil? && expanded_property == '@value' && input_type != '@json'
           next
         end
@@ -619,7 +619,7 @@ module JSON::LD
             if id_context.nil?
               context
             else
-              log_debug("expand", depth: log_depth.to_i) {"id_context: #{id_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"id_context: #{id_context.inspect}"}
               context.parse(id_context, base: @options[:base], propagate: false)
             end
           else
@@ -632,7 +632,7 @@ module JSON::LD
             # If container mapping in the active context includes @type, and k is a term in the active context having a local context, use that context when expanding values
             map_context = container_context.term_definitions[k].context if container.include?('@type') && container_context.term_definitions[k]
             unless map_context.nil?
-              log_debug("expand", depth: log_depth.to_i) {"map_context: #{map_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"map_context: #{map_context.inspect}"}
               map_context = container_context.parse(map_context, base: @options[:base],
                                                     propagate: false)
             end
@@ -688,21 +688,21 @@ module JSON::LD
 
         # If expanded value is null, ignore key by continuing to the next key from element.
         if expanded_value.nil?
-          log_debug(" => skip nil value", depth: log_depth.to_i)
+          # log_debug(" => skip nil value", depth: log_depth.to_i)
           next
         end
-        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        # log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
         if container.first == '@list' && container.length == 1 && !list?(expanded_value)
-          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          # log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = {'@list' => as_array(expanded_value)}
         end
-        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        # log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # convert expanded value to @graph if container specifies it
         if container.first == '@graph' && container.length == 1
-          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          # log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = as_array(expanded_value).map do |v|
             {'@graph' => as_array(v)}
           end
@@ -742,7 +742,7 @@ module JSON::LD
         nest_context = if nest_context.nil?
           context
         else
-          log_debug("expand", depth: log_depth.to_i) {"nest_context: #{nest_context.inspect}"}
+          # log_debug("expand", depth: log_depth.to_i) {"nest_context: #{nest_context.inspect}"}
           context.parse(nest_context, base: @options[:base],
                         override_protected: true)
         end

data/lib/json/ld/from_rdf.rb

@@ -14,9 +14,11 @@ module JSON::LD
     # @param [Boolean] useRdfType (false)
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @param [Boolean] useNativeTypes (false) use native representations
+    # @param extendedRepresentation (false)
+    #   Use the extended internal representation for native types.
     #
     # @return [Array<Hash>] the JSON-LD document in normalized form
-    def from_statements(dataset, useRdfType: false, useNativeTypes: false)
+    def from_statements(dataset, useRdfType: false, useNativeTypes: false, extendedRepresentation: false)
       default_graph = {}
       graph_map = {'@default' => default_graph}
       referenced_once = {}
@@ -30,7 +32,7 @@ module JSON::LD
 
       # For each statement in dataset
       dataset.each do |statement|
-        #log_debug("statement") { statement.to_nquads.chomp}
+        # log_debug("statement") { statement.to_nquads.chomp}
 
         name = statement.graph_name ? @context.expand_iri(statement.graph_name, base: @options[:base]).to_s : '@default'
 
@@ -41,9 +43,9 @@ module JSON::LD
         default_graph[name] ||= {'@id' => name} unless name == '@default'
 
         subject = statement.subject.statement? ?
-          resource_representation(statement.subject, useNativeTypes)['@id'].to_json_c14n :
+          resource_representation(statement.subject, useNativeTypes, extendedRepresentation)['@id'].to_json_c14n :
           statement.subject.to_s
-        node = node_map[subject] ||= resource_representation(statement.subject, useNativeTypes)
+        node = node_map[subject] ||= resource_representation(statement.subject, useNativeTypes, extendedRepresentation)
 
         # If predicate is rdf:datatype, note subject in compound literal subjects map
         if @options[:rdfDirection] == 'compound-literal' && statement.predicate == RDF.to_uri + 'direction'
@@ -53,10 +55,10 @@ module JSON::LD
         # If object is an IRI, blank node identifier, or statement, and node map does not have an object member, create one and initialize its value to a new JSON object consisting of a single member @id whose value is set to object.
         unless statement.object.literal?
           object = statement.object.statement? ?
-            resource_representation(statement.object, useNativeTypes)['@id'].to_json_c14n :
+            resource_representation(statement.object, useNativeTypes, extendedRepresentation)['@id'].to_json_c14n :
             statement.object.to_s
           node_map[object] ||=
-            resource_representation(statement.object, useNativeTypes)
+            resource_representation(statement.object, useNativeTypes, extendedRepresentation)
         end
 
         # If predicate equals rdf:type, and object is an IRI or blank node identifier, append object to the value of the @type member of node. If no such member exists, create one and initialize it to an array whose only item is object. Finally, continue to the next RDF triple.
@@ -66,7 +68,7 @@ module JSON::LD
         end
 
         # Set value to the result of using the RDF to Object Conversion algorithm, passing object, rdfDirection, and use native types.
-        value = resource_representation(statement.object, useNativeTypes)
+        value = resource_representation(statement.object, useNativeTypes, extendedRepresentation)
 
         merge_value(node, statement.predicate.to_s, value)
 
@@ -124,7 +126,7 @@ module JSON::LD
           list, list_nodes = [], []
 
           # If property equals rdf:rest, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Continue with the following steps:
-          #log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
+          # log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
           while property == RDF.rest.to_s &&
               blank_node?(node) &&
               referenced_once[node['@id']] &&
@@ -163,31 +165,68 @@ module JSON::LD
         node.delete(:usages)
         result << node unless node_reference?(node)
       end
-      #log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
+      # log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
       result
     end
 
     private
-    def resource_representation(resource, useNativeTypes)
+
+    RDF_LITERAL_NATIVE_TYPES = Set.new([RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double]).freeze
+
+    def resource_representation(resource, useNativeTypes, extendedRepresentation)
       case resource
       when RDF::Statement
         # Note, if either subject or object are a BNode which is used elsewhere,
         # this might not work will with the BNode accounting from above.
-        rep = {'@id' => resource_representation(resource.subject, false)}
+        rep = {'@id' => resource_representation(resource.subject, false, extendedRepresentation)}
         if resource.predicate == RDF.type
           rep['@id'].merge!('@type' => resource.object.to_s)
         else
           rep['@id'].merge!(
             resource.predicate.to_s =>
-            as_array(resource_representation(resource.object, useNativeTypes)))
+            as_array(resource_representation(resource.object, useNativeTypes, extendedRepresentation)))
         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 useNativeTypes && extendedRepresentation
+          res['@value'] = resource  # Raw literal
+        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

data/lib/json/ld/streaming_writer.rb

@@ -19,7 +19,7 @@ module JSON::LD
       else Context.parse(@options[:context])
       end
 
-      #log_debug("prologue") {"context: #{context.inspect}"}
+      # log_debug("prologue") {"context: #{context.inspect}"}
       if context
         @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
       else
@@ -39,7 +39,7 @@ module JSON::LD
     #
     # @return [void] `self`
     def stream_statement(statement)
-      #log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
+      # log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
       if @current_graph != statement.graph_name
         end_graph
         start_graph(statement.graph_name)
@@ -76,7 +76,7 @@ module JSON::LD
     # Complete open statements
     # @return [void] `self`
     def stream_epilogue
-      #log_debug("epilogue") {"state: #{@state.inspect}"}
+      # log_debug("epilogue") {"state: #{@state.inspect}"}
       end_graph
       if context
         @output.puts "\n]}"
@@ -89,7 +89,7 @@ module JSON::LD
     private
     
     def start_graph(resource)
-      #log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
+      # log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
       if resource
         @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
         @output.puts %({"@id": "#{resource}", "@graph": [)
@@ -99,7 +99,7 @@ module JSON::LD
     end
 
     def end_graph
-      #log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
+      # log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
       end_node
       if @current_graph
         @output.write %(]})
@@ -108,7 +108,7 @@ module JSON::LD
     end
 
     def end_node
-      #log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
+      # log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
       @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
       if @current_node_def
         node_def = if context

data/lib/json/ld/to_rdf.rb

@@ -25,6 +25,8 @@ module JSON::LD
         datatype = RDF::URI(RDF.to_uri + "JSON") if datatype == '@json'
 
         case value
+        when RDF::Value
+          return value
         when TrueClass, FalseClass
           # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
           value = value.to_s
@@ -88,14 +90,14 @@ module JSON::LD
         to_enum(:item_to_rdf, item['@id'], quoted: true).to_a.first
       end
 
-      #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
+      # log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
       item.each do |property, values|
         case property
         when '@type'
           # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
           values.each do |v|
             object = as_resource(v)
-            #log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
+            # log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
             yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name, quoted: quoted)
           end
         when '@graph'
@@ -107,12 +109,12 @@ module JSON::LD
           raise "Huh?" unless values.is_a?(Hash)
           values.each do |prop, vv|
             predicate = as_resource(prop)
-            #log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+            # log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
             # For each item in values
             vv.each do |v|
               # Item is a node definition. Generate object as the result of the Object Converstion algorithm passing item.
               object = item_to_rdf(v, graph_name: graph_name, &block)
-              #log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+              # log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
               # yield subject, prediate, and literal to results.
               yield RDF::Statement(object, predicate, subject, graph_name: graph_name, quoted: quoted)
             end
@@ -127,12 +129,12 @@ module JSON::LD
           # Otherwise, property is an IRI or Blank Node identifier
           # Initialize predicate from  property as an IRI or Blank node
           predicate = as_resource(property)
-          #log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+          # log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
 
           # For each item in values
           values.each do |v|
             if list?(v)
-              #log_debug("item_to_rdf")  {"list: #{v.inspect}"}
+              # log_debug("item_to_rdf")  {"list: #{v.inspect}"}
               # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
               object = parse_list(v['@list'], graph_name: graph_name, &block)
 
@@ -141,7 +143,7 @@ module JSON::LD
             else
               # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
               object = item_to_rdf(v, graph_name: graph_name, &block)
-              #log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
+              # log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
               # yield subject, prediate, and literal to results.
               yield RDF::Statement(subject, predicate, object, graph_name: graph_name, quoted: quoted)
             end
@@ -162,7 +164,7 @@ module JSON::LD
     # @return [Array<RDF::Statement>]
     #   Statements for each item in the list
     def parse_list(list, graph_name: nil, &block)
-      #log_debug('parse_list') {"list: #{list.inspect}"}
+      # log_debug('parse_list') {"list: #{list.inspect}"}
 
       last = list.pop
       result = first_bnode = last ? node : RDF.nil

data/lib/json/ld/writer.rb

@@ -298,7 +298,7 @@ module JSON::LD
         stream_epilogue
       else
 
-        log_debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
+        # log_debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
         result = API.fromRdf(@repo, **@options.merge(serializer: nil))
 
         # Some options may be indicated from accept parameters
@@ -326,11 +326,11 @@ module JSON::LD
 
         if frame = @options[:frame]
           # Perform framing, if given a frame
-          log_debug("writer") { "frame result"}
+          # log_debug("writer") { "frame result"}
           result = API.frame(result, frame, **@options.merge(serializer: nil))
         elsif context
           # Perform compaction, if we have a context
-          log_debug("writer") { "compact result"}
+          # log_debug("writer") { "compact result"}
           result = API.compact(result, context,  **@options.merge(serializer: nil))
         end
 

data/spec/context_spec.rb

@@ -655,7 +655,6 @@ describe JSON::LD::Context do
           "@language" => "en"
         }
       }, logger)
-      expect(subject.to_rb).not_to be_empty
     end
 
     it "@vocab" do
@@ -665,7 +664,6 @@ describe JSON::LD::Context do
           "@vocab" => "http://example.com/"
         }
       }, logger)
-      expect(subject.to_rb).not_to be_empty
     end
 
     it "term mappings" do
@@ -676,7 +674,6 @@ describe JSON::LD::Context do
           "foo" => "http://example.com/"
         }
       }, logger)
-      expect(c.to_rb).not_to be_empty
     end
 
     it "@context" do
@@ -931,6 +928,37 @@ describe JSON::LD::Context do
 
   end
 
+  describe "#to_rb" do
+    before(:all) {JSON::LD::Context.instance_variable_set(:@cache, nil)}
+    subject {
+      allow(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
+      context.parse("http://example.com/context")
+    }
+
+    it "encodes as utf-8" do
+      expect(subject.to_rb).to match(/encoding: utf-8/)
+    end
+
+    it "marked as auto-generated" do
+      expect(subject.to_rb).to match(/This file generated automatically from/)
+    end
+
+    it "includes URL in preloaded" do
+      expect(subject.to_rb).to include(%(add_preloaded("http://example.com/context")))
+    end
+
+    it "includes processingMode" do
+      expect(subject.to_rb).to include(%(processingMode: "json-ld-1.1"))
+    end
+
+    it "term mappings" do
+      expect(subject.to_rb).to include(%("avatar" => TermDefinition.new("avatar", id: "http://xmlns.com/foaf/0.1/avatar", type_mapping: "@id")))
+      expect(subject.to_rb).to include(%("homepage" => TermDefinition.new("homepage", id: "http://xmlns.com/foaf/0.1/homepage", type_mapping: "@id")))
+      expect(subject.to_rb).to include(%("name" => TermDefinition.new("name", id: "http://xmlns.com/foaf/0.1/name", simple: true)))
+      expect(subject.to_rb).to include(%("xsd" => TermDefinition.new("xsd", id: "http://www.w3.org/2001/XMLSchema#", simple: true, prefix: true)))
+    end
+  end
+
   describe "#base=" do
     subject {
       context.parse({
@@ -1553,14 +1581,6 @@ describe JSON::LD::Context do
       "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}],

data/spec/frame_spec.rb

@@ -2463,6 +2463,49 @@ describe JSON::LD::API do
         }),
         processingMode: "json-ld-1.1"
       },
+      "issue #142": {
+        input: %({
+          "@context":{
+            "ex":"http://example.org/vocab#",
+            "ex:info":{"@type":"@json"},
+            "ex:other":{"@type":"@json"}
+          },
+          "@id":"http://example.org/test/#library",
+          "@type":"ex:Library",
+          "ex:info":{
+            "author":"JOHN",
+            "pages":200
+          },
+          "ex:other":{
+            "publisher":"JANE"
+          }
+        }),
+        frame: %({
+          "@context":{
+            "ex":"http://example.org/vocab#",
+            "ex:info":{"@type":"@json"},
+            "ex:other":{"@type":"@json"}
+          },
+          "http://example.org/vocab#info":{}
+        }),
+        output: %({
+          "@context": {
+            "ex": "http://example.org/vocab#",
+            "ex:info": {"@type": "@json"},
+            "ex:other": {"@type": "@json"}
+          },
+          "@id": "http://example.org/test/#library",
+          "@type": "ex:Library",
+          "ex:info": {
+            "author": "JOHN",
+            "pages": 200
+          },
+          "ex:other": {
+            "publisher": "JANE"
+          }
+        }),
+        processingMode: "json-ld-1.1"  
+      }
     }.each do |title, params|
       it title do
         do_frame(params)