Support :unique_bnodes option to make sure that randomized BNode lables are generated when flattening or writing.

Author: gkellogg

Gemfile

@@ -12,7 +12,7 @@ end
 
 group :debug do
   gem "wirble"
-  gem "byebug", :platforms => :mri_20
+  gem "byebug", :platforms => [:mri_20, :mri_21]
 end
 
 platforms :rbx do

lib/json/ld/api.rb

@@ -72,14 +72,16 @@ class API
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
+    # @option options [Boolean]  :unique_bnodes   (false)
+    #   Use unique bnode identifiers, defaults to using the identifier which the node was originall initialized with (if any).
     # @yield [api]
     # @yieldparam [API]
     def initialize(input, context, options = {}, &block)
       @options = {:compactArrays => true}.merge(options)
       @options[:validate] = true if @options[:processingMode] == "json-ld-1.0"
       @options[:documentLoader] ||= self.class.method(:documentLoader)
       options[:rename_bnodes] ||= true
-      @namer = options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new
+      @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
       @value = case input
       when Array, Hash then input.dup
       when IO, StringIO

lib/json/ld/utils.rb

@@ -163,6 +163,23 @@ def get_name(old = "")
     end
   end
 
+  class BlankNodeUniqer < BlankNodeMapper
+    ##
+    # Use the uniquely generated bnodes, rather than a sequence
+    # @param [String] old ("")
+    # @return [String]
+    def get_sym(old = "")
+      old = old.to_s.sub(/_:/, '')
+      if old && self.has_key?(old)
+        self[old]
+      elsif !old.empty?
+        self[old] = RDF::Node.new.to_unique_base[2..-1]
+      else
+        RDF::Node.new.to_unique_base[2..-1]
+      end
+    end
+  end
+
   class BlankNodeNamer < BlankNodeMapper
     # @param [String] prefix
     def initialize(prefix)

lib/json/ld/writer.rb

@@ -85,6 +85,8 @@ def self.to_sym
     #   Add standard prefixes to @prefixes, if necessary.
     # @option options [IO, Array, Hash, String, Context]     :context     ({})
     #   context to use when serializing. Constructed context for native serialization.
+    # @option options [Boolean]  :unique_bnodes   (false)
+    #   Use unique bnode identifiers, defaults to using the identifier which the node was originall initialized with (if any).
     # @yield  [writer] `self`
     # @yieldparam  [RDF::Writer] writer
     # @yieldreturn [void]
@@ -160,7 +162,12 @@ def write_epilogue
         end if @options[:prefixes]
         ctx
       end
-      
+
+      # Rename BNodes to uniquify them, if necessary
+      if options[:unique_bnodes]
+        result = API.flatten(result, context, @options)
+      end
+
       # Perform compaction, if we have a context
       if context
         debug("writer") { "compact result"}

spec/to_rdf_spec.rb

@@ -25,6 +25,13 @@
           }),
           %q([ <http://example.com/foo> "bar"^^xsd:string] .)
         ],
+        "@id with _:a and reference" => [
+          %q({
+            "@id": "_:a",
+            "http://example.com/foo": {"@id": "_:a"}
+          }),
+          %q(_:a <http://example.com/foo> _:a] .)
+        ],
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
@@ -660,7 +667,7 @@
   def parse(input, options = {})
     @debug = []
     graph = options[:graph] || RDF::Graph.new
-    options = {:debug => @debug, :validate => true, :canonicalize => false}.merge(options)
+    options = {debug: @debug, validate: true, canonicalize: false}.merge(options)
     JSON::LD::API.toRdf(StringIO.new(input), options) {|st| graph << st}
     graph
   end

spec/writer_spec.rb

@@ -20,24 +20,23 @@
       {:content_type   => 'application/x-ld+json'},
     ].each do |arg|
       it "discovers with #{arg.inspect}" do
-        RDF::Reader.for(arg).should == JSON::LD::Reader
+        expect(RDF::Reader.for(arg)).to eql JSON::LD::Reader
       end
     end
   end
 
   context "simple tests" do
     it "should use full URIs without base" do
       input = %(<http://a/b> <http://a/c> <http://a/d> .)
-      serialize(input).should produce([{
+      expect(serialize(input)).to produce([{
         '@id'         => "http://a/b",
         "http://a/c"  => [{"@id" => "http://a/d"}]
       }], @debug)
     end
 
     it "should use qname URIs with standard prefix" do
       input = %(<http://xmlns.com/foaf/0.1/b> <http://xmlns.com/foaf/0.1/c> <http://xmlns.com/foaf/0.1/d> .)
-      serialize(input, :standard_prefixes => true).
-      should produce({
+      expect(serialize(input, :standard_prefixes => true)).to produce({
         '@context' => {
           "foaf"  => "http://xmlns.com/foaf/0.1/",
         },
@@ -53,12 +52,11 @@
         <https://senet.org/gm> <https://senet.org/ns#unofficialTitle> "Rhythm Tengoku"@en .
         <https://senet.org/gm> <https://senet.org/ns#urlkey> "rhythm-tengoku" .
       )
-      serialize(input, :prefixes => {
+      expect(serialize(input, :prefixes => {
         :dc    => "http://purl.org/dc/terms/",
         :frbr  => "http://vocab.org/frbr/core#",
         :senet => "https://senet.org/ns#",
-      }).
-      should produce({
+      })).to produce({
         '@context' => {
           "dc" => "http://purl.org/dc/terms/",
           "frbr" => "http://vocab.org/frbr/core#",
@@ -75,8 +73,8 @@
     it "should use CURIEs with empty prefix" do
       input = %(<http://xmlns.com/foaf/0.1/b> <http://xmlns.com/foaf/0.1/c> <http://xmlns.com/foaf/0.1/d> .)
       begin
-        serialize(input, :prefixes => { "" => RDF::FOAF}).
-        should produce({
+        expect(serialize(input, :prefixes => { "" => RDF::FOAF})).
+        to produce({
           "@context" => {
             "" => "http://xmlns.com/foaf/0.1/"
           },
@@ -92,8 +90,8 @@
 
     it "should not use terms if no suffix" do
       input = %(<http://xmlns.com/foaf/0.1/> <http://xmlns.com/foaf/0.1/> <http://xmlns.com/foaf/0.1/> .)
-      serialize(input, :standard_prefixes => true).
-      should_not produce({
+      expect(serialize(input, :standard_prefixes => true)).
+      not_to produce({
         "@context" => {"foaf" => "http://xmlns.com/foaf/0.1/"},
         '@id'   => "foaf",
         "foaf"   => {"@id" => "foaf"}
@@ -107,10 +105,10 @@
         db:Michael_Jackson dbo:artistOf <http://dbpedia.org/resource/%28I_Can%27t_Make_It%29_Another_Day> .
       )
 
-      serialize(input, :prefixes => {
+      expect(serialize(input, :prefixes => {
           "db" => RDF::URI("http://dbpedia.org/resource/"),
-          "dbo" => RDF::URI("http://dbpedia.org/ontology/")}).
-      should produce({
+          "dbo" => RDF::URI("http://dbpedia.org/ontology/")})).
+      to produce({
         "@context" => {
           "db"    => "http://dbpedia.org/resource/",
           "dbo"   => "http://dbpedia.org/ontology/"
@@ -120,15 +118,21 @@
       }, @debug)
     end
 
+    it "should not use provided node identifiers if :unique_bnodes set" do
+      input = %(_:a <http://example.com/foo> _:b \.)
+      result = serialize(input, unique_bnodes: true, context: {})
+      expect(result.to_json).to match(%r(_:g\w+))
+    end
+
     it "serializes multiple subjects" do
       input = %q(
         @prefix : <http://www.w3.org/2006/03/test-description#> .
         @prefix dc: <http://purl.org/dc/terms/> .
         <http://example.com/test-cases/0001> a :TestCase .
         <http://example.com/test-cases/0002> a :TestCase .
       )
-      serialize(input, :prefixes => {"" => "http://www.w3.org/2006/03/test-description#"}).
-      should produce({
+      expect(serialize(input, :prefixes => {"" => "http://www.w3.org/2006/03/test-description#"})).
+      to produce({
         '@context'     => {
           "" => "http://www.w3.org/2006/03/test-description#",
           "dc" => RDF::DC.to_s 
@@ -154,12 +158,12 @@
            owl:onClass <http://data.wikia.com/terms#Element>;
            owl:onProperty <http://data.wikia.com/terms#characterIn> .
       )
-      serialize(input, :rename_bnodes => false, :prefixes => {
+      expect(serialize(input, :rename_bnodes => false, :prefixes => {
         :owl  => "http://www.w3.org/2002/07/owl#",
         :rdfs => "http://www.w3.org/2000/01/rdf-schema#",
         :xsd  => "http://www.w3.org/2001/XMLSchema#"
-      }).
-      should produce({
+      })).
+      to produce({
         '@context'     => {
           "owl"  => "http://www.w3.org/2002/07/owl#",
           "rdf"  => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",