json-ld 1.1.7 → 1.1.8

data/lib/json/ld/streaming_writer.rb

@@ -0,0 +1,123 @@
+module JSON::LD
+  ##
+  # Streaming writer interface.
+  #
+  # Writes an array of statements serialized in expanded JSON-LD. No provision for turning rdf:first/rest into @list encodings.
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  module StreamingWriter
+    ##
+    # Write out array start, and note not to prepend node-separating ','
+    # @return [void] `self`
+    def stream_prologue
+
+      # If we were provided a context, or prefixes, use them to compact the output
+      @context = case @options[:context]
+      when nil then nil
+      when Context then @options[:context]
+      else Context.new.parse(@options[:context])
+      end
+
+      debug("prologue") {"context: #{context.inspect}"}
+      if context
+        @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
+      else
+        @output.puts "["
+      end
+      self
+    end
+
+    ##
+    # Write a statement, creating a current node definition, if necessary.
+    #
+    # Once a new/first statement is seen, terminate the current node definition and compact if provided a context.
+    #
+    # Also expects all statements in the same context to be contained in a block including all subjects in a block (except for list elements)
+    #
+    # Note that if list elements are not received in order using the same subject and property, this may cause a bad serialization.
+    #
+    # @return [void] `self`
+    def stream_statement(statement)
+      debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
+      if @current_graph != statement.context
+        end_graph
+        start_graph(statement.context)
+      end
+
+      # If we're writing a list
+      @current_node_def ||= {'@id' => statement.subject.to_s}
+
+      if statement.subject.to_s != @current_node_def['@id']
+        end_node
+        @current_node_def = {'@id' => statement.subject.to_s}
+      end
+
+      if statement.predicate == RDF.type
+        (@current_node_def['@type'] ||= []) << statement.object.to_s
+      else
+        pd = (@current_node_def[statement.predicate.to_s] ||= [])
+
+        pd << if statement.object.resource?
+          {'@id' => statement.object.to_s}
+        else
+          lit = {"@value" => statement.object.to_s}
+          lit["@type"] = statement.object.datatype.to_s if statement.object.has_datatype?
+          lit["@language"] = statement.object.language.to_s if statement.object.has_language?
+          lit
+        end
+      end
+      self
+    end
+
+    ##
+    # Complete open statements
+    # @return [void] `self`
+    def stream_epilogue
+      debug("epilogue") {"state: #{@state.inspect}"}
+      end_graph
+      if context
+        @output.puts "\n]}"
+      else
+        @output.puts "\n]"
+      end
+      self
+    end
+
+    private
+    
+    def start_graph(resource)
+      debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
+      if resource
+        @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
+        @output.puts %({"@id": "#{resource}", "@graph": [)
+        @state = :in_graph
+      end
+      @current_graph = resource
+    end
+
+    def end_graph
+      debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
+      end_node
+      if @current_graph
+        @output.write %(]})
+        @state = :wrote_graph
+      end
+    end
+
+    def end_node
+      debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
+      @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
+      if @current_node_def
+        node_def = if context
+          compacted = JSON::LD::API.compact(@current_node_def, context, rename_bnodes: false)
+          compacted.delete('@context')
+          compacted
+        else
+          @current_node_def
+        end
+        @output.write node_def.to_json
+        @state = :wrote_node
+        @current_node_def = nil
+      end
+    end
+  end
+end

data/lib/json/ld/to_rdf.rb

@@ -18,7 +18,7 @@ module JSON::LD
       active_graph.each do |id, node|
         # Initialize subject as the IRI or BNode representation of id
         subject = as_resource(id)
-        debug("graph_to_rdf")  {"subject: #{subject.to_ntriples} (id: #{id})"}
+        debug("graph_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'} (id: #{id})"}
 
         # For each property-values in node
         node.each do |property, values|
@@ -27,7 +27,7 @@ module JSON::LD
             # 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 |value|
               object = as_resource(value)
-              debug("graph_to_rdf")  {"type: #{object.to_ntriples}"}
+              debug("graph_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
               yield RDF::Statement.new(subject, RDF.type, object)
             end
           when /^@/
@@ -36,7 +36,7 @@ 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)
-            debug("graph_to_rdf")  {"predicate: #{predicate.to_ntriples}"}
+            debug("graph_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
 
             # For each item in values
             values.each do |item|
@@ -50,7 +50,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 = parse_object(item)
-                debug("graph_to_rdf")  {"object: #{object.to_ntriples}"}
+                debug("graph_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
                 # Append a triple composed of subject, prediate, and literal to results.
                 yield RDF::Statement.new(subject, predicate, object)
               end
@@ -77,7 +77,7 @@ module JSON::LD
           datatype ||= RDF::XSD.boolean.to_s
         when Float, Fixnum
           # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
-          lit = RDF::Literal.new(value, :canonicalize => true)
+          lit = RDF::Literal.new(value, canonicalize: true)
           value = lit.to_s
           datatype ||= lit.datatype
         else
@@ -88,7 +88,7 @@ module JSON::LD
                   
         # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
         language = item.fetch('@language', nil)
-        RDF::Literal.new(value, :datatype => datatype, :language => language)
+        RDF::Literal.new(value, datatype: datatype, language: language)
       else
         # Otherwise, value must be a node definition containing only @id whos value is an IRI or Blank Node identifier
         raise "Expected node reference, got #{item.inspect}" unless item.keys == %w(@id)

data/lib/json/ld/writer.rb

@@ -1,3 +1,4 @@
+require 'json/ld/streaming_writer'
 module JSON::LD
   ##
   # A JSON-LD parser in Ruby.
@@ -10,7 +11,7 @@ module JSON::LD
   #   RDF::Writer.for(:jsonld)         #=> JSON::LD::Writer
   #   RDF::Writer.for("etc/test.json")
   #   RDF::Writer.for(:file_name      => "etc/test.json")
-  #   RDF::Writer.for(:file_extension => "json")
+  #   RDF::Writer.for(file_extension: "json")
   #   RDF::Writer.for(:content_type   => "application/turtle")
   #
   # @example Serializing RDF graph into an JSON-LD file
@@ -36,9 +37,9 @@ module JSON::LD
   #
   # @example Creating @@context prefix definitions in output
   #   JSON::LD::Writer.buffer(
-  #     :prefixes => {
+  #     prefixes: {
   #       nil => "http://example.com/ns#",
-  #       :foaf => "http://xmlns.com/foaf/0.1/"}
+  #       foaf: "http://xmlns.com/foaf/0.1/"}
   #   ) do |writer|
   #     graph.each_statement do |statement|
   #       writer << statement
@@ -51,6 +52,7 @@ module JSON::LD
   # @see http://json-ld.org/spec/ED/20110507/#the-normalization-algorithm
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class Writer < RDF::Writer
+    include StreamingWriter
     include Utils
     format Format
 
@@ -89,6 +91,8 @@ module JSON::LD
     #   frame to use when serializing.
     # @option options [Boolean]  :unique_bnodes   (false)
     #   Use unique bnode identifiers, defaults to using the identifier which the node was originall initialized with (if any).
+    # @option options [Boolean] :stream (false)
+    #   Do not attempt to optimize graph presentation, suitable for streaming large graphs.
     # @yield  [writer] `self`
     # @yieldparam  [RDF::Writer] writer
     # @yieldreturn [void]
@@ -99,6 +103,7 @@ module JSON::LD
       options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do
         @repo = RDF::Repository.new
+        @debug = @options[:debug]
 
         if block_given?
           case block.arity
@@ -124,7 +129,13 @@ module JSON::LD
     # @param  [RDF::Statement] statement
     # @return [void]
     def write_statement(statement)
-      @repo.insert(statement)
+      case
+      when @options[:stream]
+        stream_statement(statement)
+      else
+        # Add to repo and output in epilogue
+        @repo.insert(statement)
+      end
     end
 
     ##
@@ -136,7 +147,19 @@ module JSON::LD
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def write_triple(subject, predicate, object)
-      @repo.insert(Statement.new(subject, predicate, object))
+      write_statement(Statement.new(subject, predicate, object))
+    end
+
+    ##
+    # Necessary for streaming
+    # @return [void] `self`
+    def write_prologue
+      case
+      when @options[:stream]
+        stream_prologue
+      else
+        super
+      end
     end
 
     ##
@@ -148,7 +171,7 @@ module JSON::LD
     # @return [void]
     # @see    #write_triple
     def write_epilogue
-      @debug = @options[:debug]
+      return stream_epilogue if @options[:stream]
 
       debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
       result = API.fromRdf(@repo, @options)

data/spec/api_spec.rb

@@ -5,6 +5,59 @@ require 'spec_helper'
 describe JSON::LD::API do
   before(:each) { @debug = []}
 
+  describe "#initialize" do
+    context "with string input" do
+      let(:context) do
+        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
+          "@context": {
+            "xsd": "http://www.w3.org/2001/XMLSchema#",
+            "name": "http://xmlns.com/foaf/0.1/name",
+            "homepage": {"@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id"},
+            "avatar": {"@id": "http://xmlns.com/foaf/0.1/avatar", "@type": "@id"}
+          }
+        }))
+      end
+      let(:remote_doc) do
+        JSON::LD::API::RemoteDocument.new("http://example.com/foo", %q({
+          "@id": "",
+          "name": "foo"
+        }), "http://example.com/context")
+      end
+
+      it "loads document with loader and loads context" do
+        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/foo", anything).and_return(remote_doc)
+        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
+        JSON::LD::API.new("http://example.com/foo", nil)
+      end
+    end
+
+    context "with RDF::Util::File::RemoteDoc input" do
+      let(:context) do
+        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
+          "@context": {
+            "xsd": "http://www.w3.org/2001/XMLSchema#",
+            "name": "http://xmlns.com/foaf/0.1/name",
+            "homepage": {"@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id"},
+            "avatar": {"@id": "http://xmlns.com/foaf/0.1/avatar", "@type": "@id"}
+          }
+        }))
+      end
+      let(:remote_doc) do
+        RDF::Util::File::RemoteDocument.new(%q({"@id": "", "name": "foo"}),
+          headers: {
+            content_type: 'application/json',
+            link: %(<http://example.com/context>; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json")
+          }
+        )
+      end
+
+      it "processes document and retrieves linked context" do
+        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
+        JSON::LD::API.new(remote_doc, nil)
+      end
+    end
+  end
+
   context "Test Files" do
     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
       test = File.basename(filename).sub(/-input\..*$/, '')
@@ -18,24 +71,24 @@ describe JSON::LD::API do
       
       context test do
         it "expands" do
-          options = {:debug => @debug}
+          options = {debug: @debug}
           options[:expandContext] = File.open(context) if context
           jld = JSON::LD::API.expand(File.open(filename), options)
           expect(jld).to produce(JSON.load(File.open(expanded)), @debug)
         end if File.exist?(expanded)
         
         it "compacts" do
-          jld = JSON::LD::API.compact(File.open(filename), File.open(context), :debug => @debug)
+          jld = JSON::LD::API.compact(File.open(filename), File.open(context), debug: @debug)
           expect(jld).to produce(JSON.load(File.open(compacted)), @debug)
         end if File.exist?(compacted) && File.exist?(context)
         
         it "frame" do
-          jld = JSON::LD::API.frame(File.open(filename), File.open(frame), :debug => @debug)
+          jld = JSON::LD::API.frame(File.open(filename), File.open(frame), debug: @debug)
           expect(jld).to produce(JSON.load(File.open(framed)), @debug)
         end if File.exist?(framed) && File.exist?(frame)
 
         it "toRdf" do
-          expect(RDF::Repository.load(filename, :debug => @debug)).to be_equivalent_graph(RDF::Repository.load(ttl), :trace => @debug)
+          expect(RDF::Repository.load(filename, debug: @debug)).to be_equivalent_graph(RDF::Repository.load(ttl), trace: @debug)
         end if File.exist?(ttl)
       end
     end

data/spec/compact_spec.rb

@@ -8,79 +8,79 @@ describe JSON::LD::API do
   describe ".compact" do
     {
       "prefix" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/a",
           "http://example.com/b" => {"@id" => "http://example.com/c"}
         },
-        :context => {"ex" => "http://example.com/"},
-        :output => {
+        context: {"ex" => "http://example.com/"},
+        output: {
           "@context" => {"ex" => "http://example.com/"},
           "@id" => "ex:a",
           "ex:b" => {"@id" => "ex:c"}
         }
       },
       "term" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/a",
           "http://example.com/b" => {"@id" => "http://example.com/c"}
         },
-        :context => {"b" => "http://example.com/b"},
-        :output => {
+        context: {"b" => "http://example.com/b"},
+        output: {
           "@context" => {"b" => "http://example.com/b"},
           "@id" => "http://example.com/a",
           "b" => {"@id" => "http://example.com/c"}
         }
       },
       "integer value" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/a",
           "http://example.com/b" => {"@value" => 1}
         },
-        :context => {"b" => "http://example.com/b"},
-        :output => {
+        context: {"b" => "http://example.com/b"},
+        output: {
           "@context" => {"b" => "http://example.com/b"},
           "@id" => "http://example.com/a",
           "b" => 1
         }
       },
       "boolean value" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/a",
           "http://example.com/b" => {"@value" => true}
         },
-        :context => {"b" => "http://example.com/b"},
-        :output => {
+        context: {"b" => "http://example.com/b"},
+        output: {
           "@context" => {"b" => "http://example.com/b"},
           "@id" => "http://example.com/a",
           "b" => true
         }
       },
       "@id" => {
-        :input => {"@id" => "http://example.org/test#example"},
-        :context => {},
-        :output => {}
+        input: {"@id" => "http://example.org/test#example"},
+        context: {},
+        output: {}
       },
       "@id coercion" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/a",
           "http://example.com/b" => {"@id" => "http://example.com/c"}
         },
-        :context => {"b" => {"@id" => "http://example.com/b", "@type" => "@id"}},
-        :output => {
+        context: {"b" => {"@id" => "http://example.com/b", "@type" => "@id"}},
+        output: {
           "@context" => {"b" => {"@id" => "http://example.com/b", "@type" => "@id"}},
           "@id" => "http://example.com/a",
           "b" => "http://example.com/c"
         }
       },
       "xsd:date coercion" => {
-        :input => {
+        input: {
           "http://example.com/b" => {"@value" => "2012-01-04", "@type" => RDF::XSD.date.to_s}
         },
-        :context => {
+        context: {
           "xsd" => RDF::XSD.to_s,
           "b" => {"@id" => "http://example.com/b", "@type" => "xsd:date"}
         },
-        :output => {
+        output: {
           "@context" => {
             "xsd" => RDF::XSD.to_s,
             "b" => {"@id" => "http://example.com/b", "@type" => "xsd:date"}
@@ -89,26 +89,26 @@ describe JSON::LD::API do
         }
       },
       "@list coercion" => {
-        :input => {
+        input: {
           "http://example.com/b" => {"@list" => ["c", "d"]}
         },
-        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@list"}},
-        :output => {
+        context: {"b" => {"@id" => "http://example.com/b", "@container" => "@list"}},
+        output: {
           "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@list"}},
           "b" => ["c", "d"]
         }
       },
       "@list coercion (integer)" => {
-        :input => {
+        input: {
           "http://example.com/term" => [
             {"@list" => [1]},
           ]
         },
-        :context => {
+        context: {
           "term4" => {"@id" => "http://example.com/term", "@container" => "@list"},
           "@language" => "de"
         },
-        :output => {
+        output: {
           "@context" => {
             "term4" => {"@id" => "http://example.com/term", "@container" => "@list"},
             "@language" => "de"
@@ -117,59 +117,59 @@ describe JSON::LD::API do
         }
       },
       "@set coercion" => {
-        :input => {
+        input: {
           "http://example.com/b" => {"@set" => ["c"]}
         },
-        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
-        :output => {
+        context: {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+        output: {
           "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
           "b" => ["c"]
         }
       },
       "empty @set coercion" => {
-        :input => {
+        input: {
           "http://example.com/b" => []
         },
-        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
-        :output => {
+        context: {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+        output: {
           "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
           "b" => []
         }
       },
       "@type with string @id" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/",
           "@type" => "#{RDF::RDFS.Resource}"
         },
-        :context => {},
-        :output => {
+        context: {},
+        output: {
           "@id" => "http://example.com/",
           "@type" => "#{RDF::RDFS.Resource}"
         },
       },
       "@type with array @id" => {
-        :input => {
+        input: {
           "@id" => "http://example.com/",
           "@type" => ["#{RDF::RDFS.Resource}"]
         },
-        :context => {},
-        :output => {
+        context: {},
+        output: {
           "@id" => "http://example.com/",
           "@type" => "#{RDF::RDFS.Resource}"
         },
       },
       "default language" => {
-        :input => {
+        input: {
           "http://example.com/term" => [
             "v5",
             {"@value" => "plain literal"}
           ]
         },
-        :context => {
+        context: {
           "term5" => {"@id" => "http://example.com/term", "@language" => nil},
           "@language" => "de"
         },
-        :output => {
+        output: {
           "@context" => {
             "term5" => {"@id" => "http://example.com/term", "@language" => nil},
             "@language" => "de"
@@ -179,7 +179,7 @@ describe JSON::LD::API do
       },
     }.each_pair do |title, params|
       it title do
-        jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
+        jld = JSON::LD::API.compact(params[:input], params[:context], debug: @debug)
         expect(jld).to produce(params[:output], @debug)
       end
     end
@@ -187,62 +187,62 @@ describe JSON::LD::API do
     context "keyword aliasing" do
       {
         "@id" => {
-          :input => {
+          input: {
             "@id" => "",
             "@type" => "#{RDF::RDFS.Resource}"
           },
-          :context => {"id" => "@id"},
-          :output => {
+          context: {"id" => "@id"},
+          output: {
             "@context" => {"id" => "@id"},
             "id" => "",
             "@type" => "#{RDF::RDFS.Resource}"
           }
         },
         "@type" => {
-          :input => {
+          input: {
             "@type" => RDF::RDFS.Resource.to_s,
             "http://example.org/foo" => {"@value" => "bar", "@type" => "http://example.com/type"}
           },
-          :context => {"type" => "@type"},
-          :output => {
+          context: {"type" => "@type"},
+          output: {
             "@context" => {"type" => "@type"},
             "type" => RDF::RDFS.Resource.to_s,
             "http://example.org/foo" => {"@value" => "bar", "type" => "http://example.com/type"}
           }
         },
         "@language" => {
-          :input => {
+          input: {
             "http://example.org/foo" => {"@value" => "bar", "@language" => "baz"}
           },
-          :context => {"language" => "@language"},
-          :output => {
+          context: {"language" => "@language"},
+          output: {
             "@context" => {"language" => "@language"},
             "http://example.org/foo" => {"@value" => "bar", "language" => "baz"}
           }
         },
         "@value" => {
-          :input => {
+          input: {
             "http://example.org/foo" => {"@value" => "bar", "@language" => "baz"}
           },
-          :context => {"literal" => "@value"},
-          :output => {
+          context: {"literal" => "@value"},
+          output: {
             "@context" => {"literal" => "@value"},
             "http://example.org/foo" => {"literal" => "bar", "@language" => "baz"}
           }
         },
         "@list" => {
-          :input => {
+          input: {
             "http://example.org/foo" => {"@list" => ["bar"]}
           },
-          :context => {"list" => "@list"},
-          :output => {
+          context: {"list" => "@list"},
+          output: {
             "@context" => {"list" => "@list"},
             "http://example.org/foo" => {"list" => ["bar"]}
           }
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], debug: @debug)
           expect(jld).to produce(params[:output], @debug)
         end
       end
@@ -251,14 +251,14 @@ describe JSON::LD::API do
     context "term selection" do
       {
         "Uses term with nil language when two terms conflict on language" => {
-          :input => [{
+          input: [{
             "http://example.com/term" => {"@value" => "v1"}
           }],
-          :context => {
+          context: {
             "term5" => {"@id" => "http://example.com/term","@language" => nil},
             "@language" => "de"
           },
-          :output => {
+          output: {
             "@context" => {
               "term5" => {"@id" => "http://example.com/term","@language" => nil},
               "@language" => "de"
@@ -267,15 +267,15 @@ describe JSON::LD::API do
           }
         },
         "Uses subject alias" => {
-          :input => [{
+          input: [{
             "@id" => "http://example.com/id1",
             "http://example.com/id1" => {"@value" => "foo", "@language" => "de"}
           }],
-          :context => {
+          context: {
             "id1" => "http://example.com/id1",
             "@language" => "de"
           },
-          :output => {
+          output: {
             "@context" => {
               "id1" => "http://example.com/id1",
               "@language" => "de"
@@ -285,14 +285,14 @@ describe JSON::LD::API do
           }
         },
         "compact-0007" => {
-          :input => ::JSON.parse(%(
+          input: ::JSON.parse(%(
             {"http://example.org/vocab#contains": "this-is-not-an-IRI"}
           )),
-          :context => ::JSON.parse(%({
+          context: ::JSON.parse(%({
             "ex": "http://example.org/vocab#",
             "ex:contains": {"@type": "@id"}
           })),
-          :output => ::JSON.parse(%({
+          output: ::JSON.parse(%({
             "@context": {
               "ex": "http://example.org/vocab#",
               "ex:contains": {"@type": "@id"}
@@ -305,7 +305,7 @@ describe JSON::LD::API do
           input = params[:input].is_a?(String) ? JSON.parse(params[:input]) : params[:input]
           ctx = params[:context].is_a?(String) ? JSON.parse(params[:context]) : params[:context]
           output = params[:output].is_a?(String) ? JSON.parse(params[:output]) : params[:output]
-          jld = JSON::LD::API.compact(input, ctx, :debug => @debug)
+          jld = JSON::LD::API.compact(input, ctx, debug: @debug)
           expect(jld).to produce(output, @debug)
         end
       end
@@ -314,7 +314,7 @@ describe JSON::LD::API do
     context "@reverse" do
       {
         "compact-0033" => {
-          :input => %([
+          input: %([
             {
               "@id": "http://example.com/people/markus",
               "@reverse": {
@@ -328,11 +328,11 @@ describe JSON::LD::API do
               "http://xmlns.com/foaf/0.1/name": [ { "@value": "Markus Lanthaler" } ]
             }
           ]),
-          :context => %({
+          context: %({
             "name": "http://xmlns.com/foaf/0.1/name",
             "isKnownBy": { "@reverse": "http://xmlns.com/foaf/0.1/knows" }
           }),
-          :output => %({
+          output: %({
             "@context": {
               "name": "http://xmlns.com/foaf/0.1/name",
               "isKnownBy": {
@@ -352,7 +352,7 @@ describe JSON::LD::API do
           input = params[:input].is_a?(String) ? JSON.parse(params[:input]) : params[:input]
           ctx = params[:context].is_a?(String) ? JSON.parse(params[:context]) : params[:context]
           output = params[:output].is_a?(String) ? JSON.parse(params[:output]) : params[:output]
-          jld = JSON::LD::API.compact(input, ctx, :debug => @debug)
+          jld = JSON::LD::API.compact(input, ctx, debug: @debug)
           expect(jld).to produce(output, @debug)
         end
       end
@@ -372,7 +372,7 @@ describe JSON::LD::API do
           },
           "foo" => "bar"
         }
-        jld = JSON::LD::API.compact(input, ctx, :debug => @debug, :validate => true)
+        jld = JSON::LD::API.compact(input, ctx, debug: @debug, validate: true)
         expect(jld).to produce(expected, @debug)
       end
     end
@@ -389,8 +389,8 @@ describe JSON::LD::API do
           "@context" => "http://example.com/context",
           "b" => "c"
         }
-        allow(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
-        jld = JSON::LD::API.compact(input, "http://example.com/context", :debug => @debug, :validate => true)
+        allow(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
+        jld = JSON::LD::API.compact(input, "http://example.com/context", debug: @debug, validate: true)
         expect(jld).to produce(expected, @debug)
       end
     end
@@ -398,17 +398,17 @@ describe JSON::LD::API do
     context "@list" do
       {
         "1 term 2 lists 2 languages" => {
-          :input => [{
+          input: [{
             "http://example.com/foo" => [
               {"@list" => [{"@value" => "en", "@language" => "en"}]},
               {"@list" => [{"@value" => "de", "@language" => "de"}]}
             ]
           }],
-          :context => {
+          context: {
             "foo_en" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "en"},
             "foo_de" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "de"}
           },
-          :output => {
+          output: {
             "@context" => {
               "foo_en" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "en"},
               "foo_de" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "de"}
@@ -419,7 +419,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], debug: @debug)
           expect(jld).to produce(params[:output], @debug)
         end
       end
@@ -428,7 +428,7 @@ describe JSON::LD::API do
     context "language maps" do
       {
         "compact-0024" => {
-          :input => [
+          input: [
             {
               "@id" => "http://example.com/queen",
               "http://example.com/vocab/label" => [
@@ -438,11 +438,11 @@ describe JSON::LD::API do
               ]
             }
           ],
-          :context => {
+          context: {
             "vocab" => "http://example.com/vocab/",
             "label" => {"@id" => "vocab:label", "@container" => "@language"}
           },
-          :output => {
+          output: {
             "@context" => {
               "vocab" => "http://example.com/vocab/",
               "label" => {"@id" => "vocab:label", "@container" => "@language"}
@@ -456,7 +456,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], debug: @debug)
           expect(jld).to produce(params[:output], @debug)
         end
       end
@@ -465,12 +465,12 @@ describe JSON::LD::API do
     context "@graph" do
       {
         "Uses @graph given mutliple inputs" => {
-          :input => [
+          input: [
             {"http://example.com/foo" => ["foo"]},
             {"http://example.com/bar" => ["bar"]}
           ],
-          :context => {"ex" => "http://example.com/"},
-          :output => {
+          context: {"ex" => "http://example.com/"},
+          output: {
             "@context" => {"ex" => "http://example.com/"},
             "@graph" => [
               {"ex:foo"  => "foo"},
@@ -480,7 +480,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], debug: @debug)
           expect(jld).to produce(params[:output], @debug)
         end
       end
@@ -489,17 +489,17 @@ describe JSON::LD::API do
     context "exceptions" do
       {
         "@list containing @list" => {
-          :input => {
+          input: {
             "http://example.org/foo" => {"@list" => [{"@list" => ["baz"]}]}
           },
-          :exception => JSON::LD::JsonLdError::ListOfLists
+          exception: JSON::LD::JsonLdError::ListOfLists
         },
         "@list containing @list (with coercion)" => {
-          :input => {
+          input: {
             "@context" => {"http://example.org/foo" => {"@container" => "@list"}},
             "http://example.org/foo" => [{"@list" => ["baz"]}]
           },
-          :exception => JSON::LD::JsonLdError::ListOfLists
+          exception: JSON::LD::JsonLdError::ListOfLists
         },
       }.each do |title, params|
         it title do