rdf-spec 1.99.0 → 2.0.0.beta1

data/lib/rdf/spec/version.rb

@@ -13,7 +13,7 @@ module RDF; module Spec
     def self.to_str() STRING end
 
     ##
-    # @return [Array(Integer, Integer, Integer)]
-    def self.to_a() [MAJOR, MINOR, TINY] end
+    # @return [Array(String, String, String, String)]
+    def self.to_a() STRING.split(".") end
   end
 end; end

data/lib/rdf/spec/writable.rb

@@ -5,10 +5,12 @@ RSpec.shared_examples 'an RDF::Writable' do
   let(:filename) {RDF::Spec::TRIPLES_FILE}
   let(:statements) {RDF::NTriples::Reader.new(File.open(filename)).to_a}
   let(:supports_graph_name) {writable.respond_to?(:supports?) && writable.supports?(:graph_name)}
+  let(:supports_literal_equality) {writable.respond_to?(:supports?) && writable.supports?(:literal_equality)}
 
   before :each do
-    raise 'writable must be defined in with let(:readable)' unless
+    raise 'writable must be defined in with let(:writable)' unless
       defined? writable
+    skip "Unwritable resource" unless writable.respond_to?(:writable?) && writable.writable?
   end
 
   subject { writable }
@@ -20,152 +22,128 @@ RSpec.shared_examples 'an RDF::Writable' do
 
   describe "#<<" do
     it "inserts a reader" do
-      if subject.writable?
-        reader = RDF::NTriples::Reader.new(File.open(filename)).to_a
-        subject << reader
-        is_expected.to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+      reader = RDF::NTriples::Reader.new(File.open(filename)).to_a
+      subject << reader
+      is_expected.to have_statement(statement)
+      expect(subject.count).to eq count
     end
 
     it "inserts a graph" do
-      if subject.writable?
-        graph = RDF::Graph.new << statements
-        subject << graph
-        is_expected.to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+      graph = RDF::Graph.new << statements
+      subject << graph
+      is_expected.to have_statement(statement)
+      expect(subject.count).to eq count
     end
 
     it "inserts an enumerable" do
-      if subject.writable?
-        enumerable = statements.dup.extend(RDF::Enumerable)
-        subject << enumerable
-        is_expected.to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+      enumerable = statements.dup.extend(RDF::Enumerable)
+      subject << enumerable
+      is_expected.to have_statement(statement)
+      expect(subject.count).to eq count
     end
 
     it "inserts data responding to #to_rdf" do
-      if subject.writable?
-        mock = double('mock')
-        allow(mock).to receive(:to_rdf).and_return(statements)
-        subject << mock
-        is_expected.to have_statement(statement)
-        expect(subject.count).to eq count
-      end
+      mock = double('mock')
+      allow(mock).to receive(:to_rdf).and_return(statements)
+      subject << mock
+      is_expected.to have_statement(statement)
+      expect(subject.count).to eq count
     end
 
     it "inserts a statement" do
-      if subject.writable?
-        subject << statement
-        is_expected.to have_statement(statement)
-        expect(subject.count).to eq 1
-      end
+      subject << statement
+      is_expected.to have_statement(statement)
+      expect(subject.count).to eq 1
     end
   end
 
   context "when inserting statements" do
     it "should support #insert" do
-      is_expected.to respond_to(:insert) if subject.writable?
+      is_expected.to respond_to(:insert)
     end
 
     it "should not raise errors" do
-      expect { subject.insert(statement) }.not_to raise_error if subject.writable?
+      expect { subject.insert(statement) }.not_to raise_error
     end
 
     it "should support inserting one statement at a time" do
-      if subject.writable?
-        subject.insert(statement)
-        is_expected.to have_statement(statement)
-      end
+      subject.insert(statement)
+      is_expected.to have_statement(statement)
     end
 
     it "should support inserting multiple statements at a time" do
-      if subject.writable?
-        subject.insert(*statements)
-        statements.each do |statement|
-          is_expected.to have_statement(statement) unless statement.to_a.any?(&:node?)
-        end
+      subject.insert(*statements)
+      statements.each do |statement|
+        is_expected.to have_statement(statement) unless statement.to_a.any?(&:node?)
       end
     end
 
     it "should insert statements successfully" do
-      if subject.writable?
-        subject.insert(*statements)
-        expect(subject.count).to eq count
-      end
+      subject.insert(*statements)
+      expect(subject.count).to eq count
     end
 
     it "should not insert a statement twice" do
+      subject.insert(statement)
+      subject.insert(statement)
+      expect(subject.count).to eq 1
+    end
+
+    it "should insert statement with literal with unique language" do
       if subject.writable?
+        statement.object = RDF::Literal('abc', language: 'en')
         subject.insert(statement)
+
+        statement.object = RDF::Literal('abc', language: 'fi')
         subject.insert(statement)
-        expect(subject.count).to eq 1
-      end
-    end
 
-    it "should not insert an incomplete statement" do
-      if subject.writable?
-        expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(subject: nil)))}.to raise_error(ArgumentError)
-        expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(predicate: nil)))}.to raise_error(ArgumentError)
-        expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(object: nil)))}.to raise_error(ArgumentError)
-        expect(subject.count).to eql 0
+        expect(subject.count).to eq 2
       end
     end
 
-    it "should treat statements with a different context as distinct", unless: RDF::VERSION.to_s >= "1.99" do
-      if subject.writable?
-        s1 = statement.dup
-        s1.context = nil
-        s2 = statement.dup
-        s2.context = RDF::URI.new("urn:context:1")
-        s3 = statement.dup
-        s3.context = RDF::URI.new("urn:context:2")
-        subject.insert(s1)
-        subject.insert(s2)
-        subject.insert(s3)
-        # If contexts are not suported, all three are redundant
-        expect(subject.count).to eq (supports_graph_name ? 3 : 1)
-      end
-    end
+    it "should insert statement with literal with unique datatype" do
+      if subject.writable? && supports_literal_equality
+        statement.object = RDF::Literal::Decimal.new(1)
+        subject.insert(statement)
 
-    it "should treat statements with a different graph_name as distinct", if: RDF::VERSION.to_s >= "1.99" do
-      if subject.writable?
-        s1 = statement.dup
-        s1.graph_name = nil
-        s2 = statement.dup
-        s2.graph_name = RDF::URI.new("urn:context:1")
-        s3 = statement.dup
-        s3.graph_name = RDF::URI.new("urn:context:2")
-        subject.insert(s1)
-        subject.insert(s2)
-        subject.insert(s3)
-        # If graph_names are not suported, all three are redundant
-        expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+        statement.object = RDF::Literal::Integer.new(1)
+        subject.insert(statement)
+
+        expect(subject.count).to eq 2
       end
     end
-  end
-end
 
-##
-# @deprecated use `it_behaves_like "an RDF::Writable"` instead
-module RDF_Writable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Writable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Writable'`"
-  end
+    it 'inserts literal with unique lexical value' do
+      if subject.writable? && supports_literal_equality
+        statement.object = RDF::Literal::Integer.new("1")
+        subject.insert(statement)
 
-  describe 'examples for' do
-    include_examples 'an RDF::Writable' do
-      let(:writable) { @writable }
+        statement.object = RDF::Literal::Integer.new("01")
+        subject.insert(statement)
 
-      before do
-        raise '@writable must be defined' unless defined?(writable)
+        expect(subject.count).to eq 2
       end
     end
+
+    it "should not insert an incomplete statement" do
+      expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(subject: nil)))}.to raise_error(ArgumentError)
+      expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(predicate: nil)))}.to raise_error(ArgumentError)
+      expect {subject.insert(RDF::Statement.from(statement.to_hash.merge(object: nil)))}.to raise_error(ArgumentError)
+      expect(subject.count).to eql 0
+    end
+
+    it "should treat statements with a different graph_name as distinct" do
+      s1 = statement.dup
+      s1.graph_name = nil
+      s2 = statement.dup
+      s2.graph_name = RDF::URI.new("urn:context:1")
+      s3 = statement.dup
+      s3.graph_name = RDF::URI.new("urn:context:2")
+      subject.insert(s1)
+      subject.insert(s2)
+      subject.insert(s3)
+      # If graph_names are not suported, all three are redundant
+      expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+    end
   end
 end

data/lib/rdf/spec/writer.rb

@@ -10,6 +10,7 @@ RSpec.shared_examples 'an RDF::Writer' do
       defined? writer
   end
   let(:writer_class) { writer.class }
+  let(:reader_class) { writer_class.format.reader}
 
   describe ".each" do
     it "yields each writer" do
@@ -26,6 +27,28 @@ RSpec.shared_examples 'an RDF::Writer' do
         expect(r).to be_a(writer_class)
       end
     end
+
+    it "should serialize different BNodes sharing a common identifier to using different BNode ids" do
+      if reader_class
+        n1 = RDF::Node("a")
+        n2 = RDF::Node("a")
+        p = RDF::URI("http://example/pred")
+        s1 = RDF::Statement(n1, p, n1)
+        s2 = RDF::Statement(n2, p, n2)
+        s3 = RDF::Statement(n1, p, n2)
+        s4 = RDF::Statement(n2, p, n1)
+        graph = RDF::Graph.new.insert(s1, s2, s3, s4)
+        expect(graph.count).to eql 4
+        serialized = writer_class.buffer do |w|
+          w << graph
+        end
+        expect(serialized).not_to be_empty
+        graph2 = RDF::Graph.new do |g|
+          g << reader_class.new(serialized)
+        end
+        expect(graph2.count).to eql 4
+      end
+    end
   end
 
   describe ".open" do
@@ -134,10 +157,34 @@ RSpec.shared_examples 'an RDF::Writer' do
       end
     end
 
+    it "raises WriterError if writing an invalid statement" do
+      file = StringIO.new
+      expect do
+        writer_class.new(file, logger: false) do |w|
+          w << RDF::Statement(
+                 RDF::URI("http://rubygems.org/gems/rdf"),
+                 RDF::URI("http://purl.org/dc/terms/creator"),
+                 nil)
+        end
+      end.to raise_error(RDF::WriterError)
+    end
+
+    it "raises WriterError on any logged error" do
+      file = StringIO.new
+      logger = RDF::Spec.logger
+      expect do
+        writer_class.new(file, logger: logger) do |w|
+          w.log_error("some error")
+        end
+      end.to raise_error(RDF::WriterError)
+      expect(logger.to_s).to include("ERROR")
+    end
+
+    # FIXME: RSpec seems to blead over __write_epilogue_without_any_instance__ to other specs
     #it "calls #write_prologue" do
     #  writer_mock = double("writer")
-    #  writer_mock.is_expected.to_receive(:got_here)
-    #  writer_class.any_instance.is_expected.to_receive(:write_prologue)
+    #  expect(writer_mock).to receive(:got_here)
+    #  expect_any_instance_of(writer_class).to receive(:write_epilogue)
     #  writer_class.new(StringIO.new) do |r|
     #    writer_mock.got_here
     #  end
@@ -145,8 +192,8 @@ RSpec.shared_examples 'an RDF::Writer' do
     #
     #it "calls #write_epilogue" do
     #  writer_mock = double("writer")
-    #  writer_mock.is_expected.to_receive(:got_here)
-    #  writer_class.any_instance.is_expected.to_receive(:write_epilogue)
+    #  expect(writer_mock).to receive(:got_here)
+    #  expect_any_instance_of(writer_class).to receive(:write_epilogue)
     #  writer_class.new(StringIO.new) do |r|
     #    writer_mock.got_here
     #  end
@@ -173,27 +220,3 @@ RSpec.shared_examples 'an RDF::Writer' do
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Writer"` instead
-module RDF_Writer
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Writer` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Writer'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Writer' do
-      let(:writer_class) { @writer_class }
-      let(:writer) { @writer }
-
-      before do
-        raise '@writer_class must be defined' unless defined?(writer_class)
-        raise '@writer must be defined' unless defined?(writer)
-      end
-    end
-  end
-end

data/spec/countable_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/countable'
+
+describe RDF::Countable do
+  # @see lib/rdf/spec/countable.rb in rdf-spec
+  it_behaves_like 'an RDF::Countable' do
+    # The available reference implementations are `RDF::Repository` and
+    # `RDF::Graph`, but a plain Ruby array will do fine as well:
+    let(:countable) { RDF::Spec.quads.extend(described_class) }
+  end
+end

data/spec/dataset_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/dataset'
+
+describe RDF::Dataset do
+
+  let(:dataset) do
+    RDF::Repository.new do |r|
+      r.insert(*RDF::Spec.quads)
+    end.snapshot
+  end
+
+  # @see lib/rdf/spec/dataset.rb in rdf-spec
+  it_behaves_like 'an RDF::Dataset'
+end

data/spec/durable_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/durable'
+
+describe RDF::Durable do
+  # The available reference implementations are `RDF::Repository` and
+  # `RDF::Graph`, but a plain Ruby array will do fine as well
+  # FIXME
+  before { @load_durable = lambda { RDF::Repository.new } }
+
+  # @see lib/rdf/spec/countable.rb in rdf-spec
+  it_behaves_like 'an RDF::Durable'
+end

data/spec/enumerable_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/enumerable'
+
+describe RDF::Enumerable do
+  # @see lib/rdf/spec/enumerable.rb in rdf-spec
+  it_behaves_like 'an RDF::Enumerable' do
+    # The available reference implementations are `RDF::Repository` and
+    # `RDF::Graph`, but a plain Ruby array will do fine as well:
+    let(:enumerable) { RDF::Spec.quads.extend(described_class) }
+  end
+end

data/spec/format_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/format'
+require 'rdf/ntriples'
+require 'rdf/nquads'
+
+describe RDF::Format do
+
+  # @see lib/rdf/spec/format.rb in rdf-spec
+  it_behaves_like 'an RDF::Format' do
+    let(:format_class) { described_class }
+  end
+end

data/spec/http_adapter_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'webmock/rspec'
+require 'rdf/ntriples'
+require 'rdf/spec/http_adapter'
+
+context "HTTP Adapters" do
+  before(:each) {WebMock.disable_net_connect!}
+  after(:each) {WebMock.allow_net_connect!}
+
+  context "using Net::HTTP" do
+    it_behaves_like 'an RDF::HttpAdapter' do
+      let(:http_adapter) { RDF::Util::File::NetHttpAdapter }
+    end
+  end
+end

data/spec/indexable.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/indexable'
+
+describe RDF::Indexable do
+  # @see lib/rdf/spec/indexable.rb in rdf-spec
+  it_behaves_like 'an RDF::Indexable' do
+    # The available reference implementations are `RDF::Repository` and
+    # `RDF::Graph`, but a double will do fine as well:
+    let(:indexable) do
+      d = double("Indexable").extend(RDF::Indexable)
+      allow(d).to receive(:index!) {d}
+      d
+    end
+  end
+end