rdf-spec 1.99.0 → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f20ea6160511bc458dbf138ed1fe61d828f1d40
-  data.tar.gz: 03830cb0bc7e6322ed30a39a9938a64be387728c
+  metadata.gz: d6c4e07996e14e39f5680298b067deb592c89412
+  data.tar.gz: 3b418d1e0af6691520024e00c6742993d8f55cff
 SHA512:
-  metadata.gz: bd8eb7f3e272f487d4f1114a4df4cc68b061e81f36cb4b3355578d6b254ce92efa1f1e8304aae27191c35383221212f430e95cb2c747b285273c85331fc0be92
-  data.tar.gz: 83afd3996484fcec39368ece2024c2ba15f04ec6bcb213ddd59f817816eead5fe124493b54c2d52b22dd4c481598d6f7f78de7c204d661cae53b286365c58e13
+  metadata.gz: 95437e8b1f673a0ba04145c6e2dfcc749d454d66d92e93de3486ca7e508f2908fe8a25080200b339cc77adfdba09443acb962f03fa6b8dadbe8ce6b385bdddcc
+  data.tar.gz: dd579471099ff0b7f84ede5a437167c94c444395e0e58a06b7ce7a6624b667d13707fc2afb3d26f9ce92f9a06d3831902128f5e97b2bdcc81770bd8638739dc6

data/{README → README.md}

@@ -6,6 +6,8 @@ and shared examples for Ruby projects that use RDF.rb and RSpec.
 * <http://github.com/ruby-rdf/rdf-spec>
 
 [![Gem Version](https://badge.fury.io/rb/rdf-spec.png)](http://badge.fury.io/rb/rdf-spec)
+[![Build Status](https://travis-ci.org/ruby-rdf/rdf-spec.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-spec)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf-spec/badge.svg)](https://coveralls.io/r/ruby-rdf/rdf-spec)
 
 ## Documentation
 

data/VERSION

@@ -1 +1 @@
-1.99.0
+2.0.0.beta1

data/lib/rdf/spec.rb

@@ -1,4 +1,5 @@
 require 'rdf'   # @see http://rubygems.org/gems/rdf
+require 'rdf/isomorphic' # @see http://rubygems.org/gems/rdf-isomorphic
 require 'rspec' # @see http://rubygems.org/gems/rspec
 require 'rdf/spec/inspects'
 require 'rspec/its'
@@ -68,5 +69,22 @@ module RDF
       require 'rdf/ntriples'
       (@triples ||=  RDF::NTriples::Reader.new(File.open(TRIPLES_FILE)).to_a).dup
     end
+
+    # Logger used for Specs; allows clearing and converting to string
+    require 'logger'
+    def self.logger
+      logger = Logger.new(StringIO.new)
+      def logger.clear
+        @logdev.instance_variable_set(:@dev, StringIO.new)
+      end
+      def logger.to_s
+        dev = @logdev.instance_variable_get(:@dev)
+        dev.rewind
+        dev.read
+      end
+      logger.level = Logger::DEBUG
+      logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+      logger
+    end
   end # Spec
 end # RDF

data/lib/rdf/spec/countable.rb

@@ -3,17 +3,16 @@ require 'rdf/spec'
 RSpec.shared_examples 'an RDF::Countable' do
   include RDF::Spec::Matchers
 
+  let(:statements) {RDF::Spec.quads}
   before do
     raise 'countable must be set with `let(:countable)' unless
       defined? countable
 
-    @statements = RDF::Spec.quads
-
     if countable.empty?
       if (countable.writable? rescue false)
-        countable.send(:insert_statements, @statements)
+        countable.send(:insert_statements, statements)
       elsif countable.respond_to?(:<<)
-        @statements.each { |statement| countable << statement }
+        statements.each { |statement| countable << statement }
       else
         raise "+countable+ must respond to #<< or be pre-populated with the" \
               "statements in #{RDF::Spec::TRIPLES_FILE} in a before block"
@@ -27,9 +26,9 @@ RSpec.shared_examples 'an RDF::Countable' do
     it {is_expected.to respond_to(:empty?)}
     it {is_expected.to_not be_empty}
     it {is_expected.to respond_to(:count)}
-    its(:count) {is_expected.to eq @statements.size}
+    its(:count) {is_expected.to eq statements.size}
     it {is_expected.to respond_to(:size)}
-    its(:size) {is_expected.to eq @statements.size}
+    its(:size) {is_expected.to eq statements.size}
 
     context "when empty" do
       subject {[].extend(RDF::Countable)}
@@ -45,25 +44,3 @@ RSpec.shared_examples 'an RDF::Countable' do
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Countable"` instead
-module RDF_Countable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Countable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Countable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Countable' do
-      let(:countable) { @countable }
-
-      before do
-        raise '@countable must be defined' unless defined?(countable)
-      end
-    end
-  end
-end

data/lib/rdf/spec/dataset.rb

@@ -0,0 +1,47 @@
+require 'rdf/spec'
+
+RSpec.shared_examples 'an RDF::Dataset' do
+  include RDF::Spec::Matchers
+
+  before :each do
+    raise 'dataset must be set with `let(:dataset)' unless
+      defined? dataset
+
+    if dataset.empty?
+      raise "+dataset+ must respond be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before block"
+    end
+  end
+
+  let(:countable)    { dataset }
+  let(:enumerable)   { dataset }
+  let(:queryable)    { dataset }
+
+  context "when counting statements" do
+    require 'rdf/spec/countable'
+    it_behaves_like 'an RDF::Countable'
+  end
+
+  context "when enumerating statements" do
+    require 'rdf/spec/enumerable'
+    it_behaves_like 'an RDF::Enumerable'
+  end
+
+  context "as durable" do
+    require 'rdf/spec/durable'
+    before { @load_durable ||= lambda { dataset } }
+
+    it_behaves_like 'an RDF::Durable'
+  end
+
+  context "when querying statements" do
+    require 'rdf/spec/queryable'
+    it_behaves_like 'an RDF::Queryable'
+  end
+
+  describe '#isolation_level' do
+    it 'is an allowable isolation level' do
+      expect(described_class::ISOLATION_LEVELS)
+        .to include(dataset.isolation_level)
+    end
+  end
+end

data/lib/rdf/spec/durable.rb

@@ -6,8 +6,7 @@ require 'rdf/spec'
 #describe RDF::DataObjects::Repository do
 #  context "The SQLite adapter" do
 #    before :each do
-#      @repository = RDF::DataObjects::Repository.new "sqlite3://:memory:"
-#      @load_durable = lambda { RDF::DataObjects::Repository.new "sqlite3:test.db" }
+#      @load_durable = lambda { RDF::DataObjects::Repository.new uri: "sqlite3:test.db" }
 #    end
 #
 #    after :each do
@@ -29,38 +28,24 @@ RSpec.shared_examples 'an RDF::Durable' do
 
   it { is_expected.to respond_to(:durable?) }
 
-  it "is_expected.to support #durable?" do
+  it "supports #durable?" do
     expect([true,false]).to be_member(subject.durable?)
   end
 
   it {is_expected.to respond_to(:nondurable?)}
 
-  it "is_expected.to support #nondurable?" do
+  it "supports #nondurable?" do
     expect([true,false]).to be_member(@load_durable.call.nondurable?)
   end
 
   its(:nondurable?) {is_expected.to_not eq subject.durable?}
 
-  it "is_expected.to save contents between instantiations" do
+  it "saves contents between instantiations" do
     if subject.durable?
-      subject.load(RDF::Spec::TRIPLES_FILE)
-      expect(subject.count).to eq File.readlines(RDF::Spec::TRIPLES_FILE).size
+      subject.insert RDF::Statement(RDF::RDFS.Resource, RDF.value, "string") if subject.empty?
+      subject.close if subject.respond_to?(:close)
+      new_instance = @load_durable.call
+      expect(new_instance).not_to be_empty
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Durable"` instead
-module RDF_Durable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Durable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Durable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Durable'
-  end
-end

data/lib/rdf/spec/enumerable.rb

@@ -24,7 +24,8 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
   let(:subject_count) {@statements.map(&:subject).uniq.length}
   let(:bnode_subject_count) {@statements.map(&:subject).uniq.select(&:node?).length}
-  let(:non_bnode_statements) {@statements.reject {|s| s.subject.node? || s.object.node?}}
+  let(:non_bnode_statements) {@statements.reject(&:node?)}
+  let(:non_bnode_terms) {@statements.map(&:to_quad).flatten.compact.reject(&:node?).uniq}
 
   subject { enumerable }
   it {is_expected.to respond_to(:supports?)}
@@ -70,10 +71,10 @@ RSpec.shared_examples 'an RDF::Enumerable' do
 
   context "when enumerating statements" do
     it {is_expected.to respond_to(:statements)}
-    #its(:statements) {is_expected.to be_an_enumerator}
+    its(:statements) {is_expected.to be_a(Array)}
 
     context "#statements" do
-      specify {expect(subject.statements.to_a.size).to eq @statements.size}
+      specify {expect(subject.statements.size).to eq @statements.size}
       specify {expect(subject.statements).to all(be_a_statement)}
     end
 
@@ -129,9 +130,9 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     it {is_expected.to respond_to(:each_triple)}
     it {is_expected.to respond_to(:enum_triple)}
 
-    #its(:triples) {is_expected.to be_an_enumerator}
+    its(:triples) {is_expected.to be_a(Array)}
     context "#triples" do
-      specify {expect(subject.triples.to_a.size).to eq @statements.size}
+      specify {expect(subject.triples.size).to eq @statements.size}
       specify {expect(subject.triples).to all(be_a_triple)}
     end
 
@@ -173,9 +174,9 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     it {is_expected.to respond_to(:each_quad)}
     it {is_expected.to respond_to(:enum_quad)}
 
-    #its(:quads) {is_expected.to be_an_enumerator}
+    its(:quads) {is_expected.to be_a(Array)}
     context "#quads" do
-      specify {expect(subject.quads.to_a.size).to eq @statements.size}
+      specify {expect(subject.quads.size).to eq @statements.size}
       specify {expect(subject.quads).to all(be_a_quad)}
     end
 
@@ -220,14 +221,13 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     it {is_expected.to respond_to(:each_subject)}
     it {is_expected.to respond_to(:enum_subject)}
 
-    #its(:subjects) {is_expected.to be_an_enumerator}
     context "#subjects" do
       subject { enumerable.subjects }
-      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to be_a(Array)}
       specify {is_expected.to all(be_a_resource)}
       context "unique: false" do
         subject { enumerable.subjects(unique: false) }
-        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to be_a(Array)}
         specify {is_expected.to all(be_a_resource)}
       end
     end
@@ -271,14 +271,13 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     it {is_expected.to respond_to(:each_predicate)}
     it {is_expected.to respond_to(:enum_predicate)}
 
-    #its(:predicates) {is_expected.to be_an_enumerator}
     context "#predicates" do
       subject { enumerable.predicates }
-      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to be_a(Array)}
       specify {is_expected.to all(be_a_uri)}
       context "unique: false" do
         subject { enumerable.predicates(unique: false) }
-        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to be_a(Array)}
         specify {is_expected.to all(be_a_uri)}
       end
     end
@@ -318,14 +317,13 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     it {is_expected.to respond_to(:each_object)}
     it {is_expected.to respond_to(:enum_object)}
 
-    #its(:objects) {is_expected.to be_an_enumerator}
     context "#objects" do
       subject { enumerable.objects }
-      specify {is_expected.to be_an_enumerator}
+      specify {is_expected.to be_a(Array)}
       specify {is_expected.to all(be_a_term)}
       context "unique: false" do
         subject { enumerable.objects(unique: false) }
-        specify {is_expected.to be_an_enumerator}
+        specify {is_expected.to be_a(Array)}
         specify {is_expected.to all(be_a_term)}
       end
     end
@@ -361,89 +359,64 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     end
   end
 
-  context "when enumerating contexts", unless: RDF::VERSION.to_s >= "1.99" do
-    it {is_expected.to respond_to(:contexts)}
-    it {is_expected.to respond_to(:has_context?)}
-    it {is_expected.to respond_to(:each_context)}
-    it {is_expected.to respond_to(:enum_context)}
+  context "when enumerating terms" do
+    let(:terms) {subject.map(&:to_quad).flatten.compact.reject(&:node?).uniq}
+    it {is_expected.to respond_to(:terms)}
+    it {is_expected.to respond_to(:has_term?)}
+    it {is_expected.to respond_to(:each_term)}
+    it {is_expected.to respond_to(:enum_term)}
 
-    its(:contexts) {is_expected.to be_an_enumerator}
-    describe "#contexts" do
-      subject { enumerable.contexts }
-      specify {is_expected.to be_an_enumerator}
-      specify {is_expected.to all(be_a_resource)}
+    context "#terms" do
+      subject { enumerable.terms }
+      specify {is_expected.to be_a(Array)}
+      specify {is_expected.to all(be_a_term)}
       context "unique: false" do
-        subject { enumerable.contexts(unique: false) }
-        specify {is_expected.to be_an_enumerator}
-        specify {is_expected.to all(be_a_resource)}
+        subject { enumerable.terms(unique: false) }
+        specify {is_expected.to be_a(Array)}
+        specify {is_expected.to all(be_a_term)}
       end
     end
 
-    it "is_expected.to implement #has_context?" do
-      if @supports_named_graphs
-        @statements.each do |statement|
-          if statement.has_context?
-            expect(enumerable).to have_context(statement.context)
-          end
+    context "#has_term?" do
+      specify do
+        checked = {}
+        non_bnode_terms.each do |term|
+          expect(enumerable).to have_term(term) unless checked.has_key?(term.hash)
+          checked[term.hash] = true
         end
         uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        expect(enumerable).not_to have_context(uri)
+        expect(enumerable).not_to have_term(uri)
       end
     end
 
-    its(:each_context) {is_expected.to be_an_enumerator}
-    context "#each_context" do
-      let(:contexts) {@statements.map { |s| s.context }.uniq.compact}
-      it "has appropriate number of contexts" do
-        if @supports_named_graphs
-          expect(subject.each_context.to_a.size).to eq contexts.size
-        end
-      end
-      specify {expect(subject.each_context).to all(be_a_resource)}
-      it "is_expected.to have all contexts" do
-        subject.each_context {|value| expect(contexts).to include(value)}
-      end
+    its(:each_term) {is_expected.to be_an_enumerator}
+    context "#each_term" do
+      specify {
+        expect(subject.each_term.reject(&:node?).size).to eq non_bnode_terms.length
+      }
+      specify {expect(subject.each_term).to all(be_a_term)}
+      specify {subject.each_term {|value| expect(non_bnode_terms).to include(value) unless value.node?}}
     end
 
-    its(:enum_context) {is_expected.to be_an_enumerator}
-    its(:enum_context) {is_expected.to be_countable}
-    context "#enum_context" do
-      it "should enumerate all contexts" do
-        expect(subject.enum_context.to_a).to include(*enumerable.each_context.to_a)
+    its(:enum_term) {is_expected.to be_an_enumerator}
+    its(:enum_term) {is_expected.to be_countable}
+    context "#enum_term" do
+      it "should enumerate all terms" do
+        subject.enum_term.each do |o|
+          expect(o).to be_a_term
+          expect(non_bnode_terms.to_a).to include(o) unless o.node?
+        end
       end
     end
   end
 
   context "when enumerating graphs" do
-    it {is_expected.to respond_to(:each_graph)}
-    it {is_expected.to respond_to(:enum_graph)}
-
-    describe "#each_graph" do
-      subject { enumerable.each_graph }
-      it {is_expected.to be_an_enumerator}
-      specify {is_expected.to all(be_a_graph)} if @supports_named_graphs
-      specify {expect(subject.each_graph).to all(be_a_graph)}
-
-      it "has appropriate number of graphs" do
-        graph_names = @statements.map { |s| s.graph_name }.uniq.compact
-        expect(subject.each_graph.to_a.size).to eq (graph_names.size + 1)
-      end if @supports_named_graphs
-    end
-
-    describe "#enum_graph" do
-      subject { enumerable.enum_graph }
-      it {is_expected.to be_an_enumerator}
-      it {is_expected.to be_countable}
-      it "enumerates the same as #each_graph" do
-        expect(subject.to_a).to include(*enumerable.each_graph.to_a) if @supports_named_graphs # expect with match problematic
-      end
-    end
-  end
-
-  context "when enumerating graphs", if: RDF::VERSION.to_s >= "1.99" do
     it {is_expected.to respond_to(:graph_names)}
     it {is_expected.to respond_to(:has_graph?)}
+    it {is_expected.to respond_to(:each_graph)}
+    it {is_expected.to respond_to(:enum_graph)}
 
+    its(:graph_names) {is_expected.to be_a(Array)}
     describe "#graph_names" do
       subject { enumerable.graph_names }
       specify {is_expected.to be_a(Array)}
@@ -455,7 +428,7 @@ RSpec.shared_examples 'an RDF::Enumerable' do
       end
     end
 
-    describe "#has_graph?" do
+    it "should implement #has_graph?" do
       if @supports_named_graphs
         @statements.each do |statement|
           if statement.has_graph?
@@ -466,8 +439,73 @@ RSpec.shared_examples 'an RDF::Enumerable' do
         expect(enumerable).not_to have_graph(uri)
       end
     end
+
+    describe "#project_graph" do
+      it {is_expected.to respond_to(:project_graph)}
+
+      context "default graph" do
+        let(:graph_name) {nil}
+        specify {expect(subject.project_graph(graph_name)).to all(be_a_statement)}
+
+        it "should return default triples" do
+          expect(subject.project_graph(graph_name).count).to eql(subject.reject(&:graph_name).count)
+        end
+
+        it "should iterate over default triples" do
+          subject.project_graph(graph_name) do |statement|
+            expect(statement.graph_name).to be_nil
+          end
+        end
+      end
+
+      context "named graph" do
+        let(:graph_name) {enumerable.graph_names.first}
+        specify {expect(subject.project_graph(graph_name)).to all(be_a_statement)}
+
+        it "should return named triples" do
+          expect(subject.project_graph(graph_name).count).to eql(subject.select {|s| s.graph_name == graph_name}.count)
+        end
+
+        it "should iterate over named triples" do
+          subject.project_graph(graph_name) do |statement|
+            expect(statement.graph_name).to eql graph_name
+          end
+        end
+      end
+
+      context "non-existing graph" do
+        let(:graph_name) {RDF::URI.new('http://example.org/does/not/have/this/uri')}
+        specify {expect(subject.project_graph(graph_name)).to be_empty if @supports_named_graphs}
+      end
+    end
+
+    its(:each_graph) {is_expected.to be_an_enumerator}
+
+    describe "#each_graph" do
+      let(:graph_names) {@statements.map { |s| s.graph_name }.uniq.compact}
+      subject { enumerable.each_graph }
+      it {is_expected.to be_an_enumerator}
+      specify {is_expected.to all(be_a_graph) if @supports_named_graphs}
+ 
+      it "has appropriate number of graphs" do
+        if @supports_named_graphs
+          graph_names = @statements.map { |s| s.graph_name }.uniq.compact
+          expect(subject.to_a.size).to eq (graph_names.size + 1)
+        end
+      end
+    end
+
+    describe "#enum_graph" do
+      subject { enumerable.enum_graph }
+      it {is_expected.to be_an_enumerator}
+      it {is_expected.to be_countable}
+      it "enumerates the same as #each_graph" do
+        expect(subject.to_a).to include(*enumerable.each_graph.to_a) if @supports_named_graphs # expect with match problematic
+      end
+    end
   end
 
+
   context "when converting" do
     it {is_expected.to respond_to(:to_hash)}
     its(:to_hash) {is_expected.to be_instance_of(Hash)}
@@ -490,25 +528,3 @@ RSpec.shared_examples 'an RDF::Enumerable' do
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Enumerable"` instead
-module RDF_Enumerable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Enumerable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Enumerable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Enumerable' do
-      let(:enumerable) { @enumerable }
-
-      before do
-        raise '@enumerable must be defined' unless defined?(enumerable)
-      end
-    end
-  end
-end