json-ld 3.2.2 → 3.2.4

data/lib/json/ld/format.rb

@@ -45,8 +45,80 @@ module JSON::LD
         !sample.include?("http://www.w3.org/ns/csvw")
     end
 
+    # Specify how to execute CLI commands for each supported format.
+    # Derived formats (e.g., YAML-LD) define their own entrypoints.
+    LD_FORMATS = {
+      jsonld: {
+        expand: ->(input, **options) {
+          JSON::LD::API.expand(input,
+                               serializer: JSON::LD::API.method(:serializer),
+                               **options)
+        },
+        compact: ->(input, **options) {
+          JSON::LD::API.compact(input,
+                                options[:context],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+        flatten: ->(input, **options) {
+          JSON::LD::API.flatten(input,
+                                options[:context],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+        frame: ->(input, **options) {
+          JSON::LD::API.frame(input,
+                                options[:frame],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+      }
+    }
+
+    # Execute the body of a CLI command, generic for each different API method based on definitions on {LD_FORMATS}.
+    #
+    # Expands the input, or transforms from an RDF format based on the `:format` option, and then executes the appropriate command based on `:output_format` and does appropriate output serialization.
+    # @private
+    def self.cli_exec(command, files, output: $stdin, **options)
+      output.set_encoding(Encoding::UTF_8) if output.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
+      options[:base] ||= options[:base_uri]
+
+      # Parse using input format, serialize using output format
+      in_fmt = LD_FORMATS[options.fetch(:format, :jsonld)]
+      out_fmt = LD_FORMATS[options.fetch(:output_format, :jsonld)]
+
+      if in_fmt
+        # Input is a JSON-LD based source (or derived)
+        if files.empty?
+          # If files are empty, either use options[:evaluate] or STDIN
+          input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+          input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+          expanded = in_fmt[:expand].call(input, serializer: nil, **options)
+          output.puts out_fmt[command].call(expanded, expanded: true, **options)
+        else
+          files.each do |file|
+            expanded = in_fmt[:expand].call(file, serializer: nil, **options)
+            output.puts out_fmt[command].call(expanded, expanded: true, **options)
+          end
+        end
+      else
+        # Turn RDF into JSON-LD first
+        RDF::CLI.parse(files, **options) do |reader|
+          JSON::LD::API.fromRdf(reader, serializer: nil, **options) do |expanded|
+            output.puts out_fmt[command].call(expanded, expanded: true, **options)
+          end
+        end
+      end
+    end
+
     ##
-    # Hash of CLI commands appropriate for this format
+    # Hash of CLI commands appropriate for this format:
+    #
+    # * `expand` => {JSON::LD::API.expand}
+    # * `compact` => {JSON::LD::API.compact}
+    # * `flatten` => {JSON::LD::API.flatten}
+    # * `frame` => {JSON::LD::API.frame}
+    #
     # @return [Hash{Symbol => Hash}]
     def self.cli_commands
       {
@@ -54,73 +126,21 @@ module JSON::LD
           description: "Expand JSON-LD or parsed RDF",
           parse: false,
           help: "expand [--context <context-file>] files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
             options = options.merge(expandContext: options.delete(:context)) if options.key?(:context)
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.expand(input, validate: false, **options) do |expanded|
-                  out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.expand(file, validate: false, **options) do |expanded|
-                    out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                end
-              end
-            end
+            cli_exec(:expand, files, **options)
           end,
           option_use: {context: :removed}
         },
         compact: {
           description: "Compact JSON-LD or parsed RDF",
           parse: false,
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           help: "compact --context <context-file> files ...",
           lambda: ->(files, **options) do
             raise ArgumentError, "Compacting requires a context" unless options[:context]
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.compact(input, options[:context], **options) do |compacted|
-                  out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.compact(file, options[:context], **options) do |compacted|
-                    out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.compact(expanded, options[:context], **options) do |compacted|
-                    out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           options: [
             RDF::CLI::Option.new(
@@ -136,36 +156,9 @@ module JSON::LD
           description: "Flatten JSON-LD or parsed RDF",
           parse: false,
           help: "flatten [--context <context-file>] files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.flatten(input, options[:context], **options) do |flattened|
-                  out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.flatten(file, options[:context], **options) do |flattened|
-                    out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.flatten(expanded, options[:context], **options) do |flattened|
-                    out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           options: [
             RDF::CLI::Option.new(
@@ -188,37 +181,10 @@ module JSON::LD
           description: "Frame JSON-LD or parsed RDF",
           parse: false,
           help: "frame --frame <frame-file>  files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
             raise ArgumentError, "Framing requires a frame" unless options[:frame]
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.frame(input, options[:frame], **options) do |framed|
-                  out.puts framed.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.frame(file, options[:frame], **options) do |framed|
-                    out.puts framed.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.frame(expanded, options[:frame], **options) do |framed|
-                    out.puts framed.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           option_use: {context: :removed},
           options: [

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)