rdf-spec 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df117f1cce44a55d080d654e85980089884ca93d
-  data.tar.gz: 4705ee929ae8d15f6c5301bb2aee44ddbff6c8b3
+  metadata.gz: bd937b914454e1beb178c07aea7f67241ef6199a
+  data.tar.gz: 5025462c4843c791c182d73f82e7901dacd8cb24
 SHA512:
-  metadata.gz: aa2a2135b703fa0c1e13831d10da184a96763767758c036123ad12caaaf93e6f2dc89fe7a6cb159323381a752dc8b4531391c5699d831e977cadc7f78bb3fa22
-  data.tar.gz: cfe5fed490a8daf14fa01fc503791dd8f0938ea6dc2f17b1863258817c76d36a027afbc1308efc0feb4b14db36c9e956d9819bcdf1031e48cc1787383af7063c
+  metadata.gz: 673c8f7b7fa7e7666585833640e61787dcdb9f5edcdf98bc3947b54832aee0d58bc4bc60cfac23fae05ffb9e96a10cc343451cf823a2726d8481e0046f0f2ee0
+  data.tar.gz: d6ccea63ee7aa054de864c8535287e84ddb6cbb791d878c7d5a10e6381addf1c6377ce5a9455bf1968dbda0933a8ff8fdf226fa78cbe8ac35921448ce5ea0635

data/VERSION

@@ -1 +1 @@
-1.1.3
+1.1.5

data/lib/rdf/spec.rb

@@ -1,5 +1,6 @@
 require 'rdf'   # @see http://rubygems.org/gems/rdf
 require 'rspec' # @see http://rubygems.org/gems/rspec
+require 'rspec/its'
 
 module RDF
   ##

data/lib/rdf/spec/countable.rb

@@ -10,7 +10,9 @@ module RDF_Countable
     @statements = RDF::Spec.quads
 
     if @countable.empty?
-      if @countable.respond_to?(:<<) && (@countable.writable? rescue true)
+      if (@countable.writable? rescue false)
+        @countable.insert_statements(@statements)
+      elsif @countable.respond_to?(:<<)
         @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(:each) block"

data/lib/rdf/spec/enumerable.rb

@@ -10,7 +10,9 @@ module RDF_Enumerable
     @statements ||= RDF::Spec.quads
 
     if @enumerable.empty?
-      if @enumerable.respond_to?(:<<) && (@enumerable.writable? rescue true)
+      if (@enumerable.writable? rescue false)
+        @enumerable.insert(*@statements)
+      elsif @enumerable.respond_to?(:<<)
         @statements.each { |statement| @enumerable << statement }
       else
         raise "@enumerable must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
@@ -439,7 +441,7 @@ module RDF_Enumerable
         subject {@enumerable.enum_graph}
         it {should be_an_enumerator}
         it {should be_countable}
-        it "enumerates the same as #each_graph", :pending => "graph inclusion issue" do
+        it "enumerates the same as #each_graph" do
           expect(subject.to_a).to include(*@enumerable.each_graph.to_a) if @supports_context # expect with match problematic
         end
       end

data/lib/rdf/spec/matchers.rb

@@ -141,10 +141,16 @@ module RDF; module Spec
       end
     end
 
-    RSpec::Matchers.define :have_subclasses do |base_uri, klasses|
+    RSpec::Matchers.define :have_terms do |base_uri, klasses|
       match do |vocabulary|
         klasses.map { |k| k.to_sym }.each do |klass|
-          pending "checks that #{base_uri} has subClassOf for #{klass}"
+          expect(vocabulary[klass]).to be_a_uri
+          expect(vocabulary[klass].to_s).to eq "#{base_uri}#{klass}"
+          expect(vocabulary).to respond_to(klass)
+          expect { vocabulary.send(klass) }.not_to raise_error
+          expect(vocabulary.send(klass)).to be_a_uri
+          expect(vocabulary.send(klass.to_s)).to be_a_uri
+          expect(vocabulary.send(klass).to_s).to eq "#{base_uri}#{klass}"
         end
         true
       end
@@ -173,5 +179,80 @@ module RDF; module Spec
         end
       end
     end
+
+    RSpec::Matchers.define :write do |message|
+      chain(:to) do |io|
+        @io = io
+      end
+
+      supports_block_expectations {true}
+
+      match do |block|
+        @output =
+          case io
+          when :output then fake_stdout(&block)
+          when :error  then fake_stderr(&block)
+          else raise("Allowed values for `to` are :output and :error, got `#{io.inspect}`")
+          end
+        case message
+        when nil, :something, :anything
+          !@output.empty?
+        when Regexp
+          message.match(@output)
+        else
+          @output.include? message
+        end
+      end
+
+      description do
+        "write \"#{message}\" #{io_name}"
+      end
+
+      failure_message do
+        @exception ? @exception.message :
+          "expected to include #{description.inspect} in #{@output.inspect}"
+      end
+
+      failure_message_when_negated do
+        @exception ? @exception.message :
+          "expected to not include #{description.inspect} in #{@output.inspect}"
+      end
+
+      # Fake $stderr and return a string written to it.
+      def fake_stderr
+        original_stderr = $stderr
+        $stderr = StringIO.new
+        yield
+        $stderr.string
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        @exception = e
+        raise
+      ensure
+        $stderr = original_stderr
+      end
+
+      # Fake $stdout and return a string written to it.
+      def fake_stdout
+        original_stdout = $stdout
+        $stdout = StringIO.new
+        yield
+        $stdout.string
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        @exception = e
+        raise
+      ensure
+        $stdout = original_stdout
+      end
+
+      # default IO is standard output
+      def io
+        @io ||= :output
+      end
+
+      # IO name is used for description message
+      def io_name
+        {:output => "standard output", :error => "standard error"}[io]
+      end
+    end
   end # Matchers
 end; end # RDF::Spec

data/lib/rdf/spec/mutable.rb

@@ -53,31 +53,27 @@ module RDF_Mutable
       end
 
       it "should accept a string filename argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
       end
 
       it "should accept an optional hash argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
       end
 
       it "should load statements" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.load RDF::Spec::TRIPLES_FILE
-          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
-          expect(subject).to have_subject(resource)
-        end
+        skip("mutability") unless subject.mutable?
+        subject.load RDF::Spec::TRIPLES_FILE
+        expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
+        expect(subject).to have_subject(resource)
       end
 
       it "should load statements with a context override" do
-        pending("mutability and contextuality", :unless => (subject.mutable? && @supports_context)) do
-          subject.load RDF::Spec::TRIPLES_FILE, :context => context
-          expect(subject).to have_context(context)
-          expect(subject.query(:context => context).size).to eq subject.size
-        end
+        skip("mutability and contextuality") unless (subject.mutable? && @supports_context)
+        subject.load RDF::Spec::TRIPLES_FILE, :context => context
+        expect(subject).to have_context(context)
+        expect(subject.query(:context => context).size).to eq subject.size
       end
     end
 
@@ -97,62 +93,57 @@ module RDF_Mutable
       end
 
       it "should not raise errors" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.delete(@statements.first) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.delete(@statements.first) }.not_to raise_error
       end
 
       it "should support deleting one statement at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(@statements.first)
-          expect(subject).not_to  have_statement(@statements.first)
-        end
+        skip("mutability") unless subject.mutable?
+        subject.delete(@statements.first)
+        expect(subject).not_to  have_statement(@statements.first)
       end
 
       it "should support deleting multiple statements at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(*@statements)
-          expect(subject.find { |s| subject.has_statement?(s) }).to be_false
-        end
+        skip("mutability") unless subject.mutable?
+        subject.delete(*@statements)
+        expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
       end
 
       it "should support wildcard deletions" do
-        pending("mutability", :unless => subject.mutable?) do
-          # nothing deleted
-          require 'digest/sha1'
-          count = subject.count
-          subject.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
-          expect(subject).not_to  be_empty
-          expect(subject.count).to eq count
-
-          # everything deleted
-          subject.delete([nil, nil, nil])
-          expect(subject).to be_empty
-        end
+        skip("mutability") unless subject.mutable?
+        # nothing deleted
+        require 'digest/sha1'
+        count = subject.count
+        subject.delete([nil, nil, Digest::SHA1.hexdigest(File.read(__FILE__))])
+        expect(subject).not_to  be_empty
+        expect(subject.count).to eq count
+
+        # everything deleted
+        subject.delete([nil, nil, nil])
+        expect(subject).to be_empty
       end
 
       it "should only delete statements when the context matches" do
-        pending("mutability", :unless => subject.mutable?) do
-          # Setup three statements identical except for context
-          count = subject.count + (@supports_context ? 3 : 1)
-          s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
-          s2 = s1.dup
-          s2.context = RDF::URI.new("urn:context:1")
-          s3 = s1.dup
-          s3.context = RDF::URI.new("urn:context:2")
-          subject.insert(s1)
-          subject.insert(s2)
-          subject.insert(s3)
-          expect(subject.count).to eq count
-
-          # Delete one by one
-          subject.delete(s1)
-          expect(subject.count).to eq count - (@supports_context ? 1 : 1)
-          subject.delete(s2)
-          expect(subject.count).to eq count - (@supports_context ? 2 : 1)
-          subject.delete(s3)
-          expect(subject.count).to eq count - (@supports_context ? 3 : 1)
-        end
+        skip("mutability") unless subject.mutable?
+        # Setup three statements identical except for context
+        count = subject.count + (@supports_context ? 3 : 1)
+        s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
+        s2 = s1.dup
+        s2.context = RDF::URI.new("urn:context:1")
+        s3 = s1.dup
+        s3.context = RDF::URI.new("urn:context:2")
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        expect(subject.count).to eq count
+
+        # Delete one by one
+        subject.delete(s1)
+        expect(subject.count).to eq count - (@supports_context ? 1 : 1)
+        subject.delete(s2)
+        expect(subject.count).to eq count - (@supports_context ? 2 : 1)
+        subject.delete(s3)
+        expect(subject.count).to eq count - (@supports_context ? 3 : 1)
       end
     end
   end

data/lib/rdf/spec/queryable.rb

@@ -11,7 +11,9 @@ module RDF_Queryable
     @statements = RDF::Spec.quads
 
     if @queryable.empty?
-      if @queryable.respond_to?(:<<) && (@queryable.writable? rescue true)
+      if (@queryable.writable? rescue false)
+        @queryable.insert(*@statements)
+      elsif @queryable.respond_to?(:<<)
         @statements.each { |statement| @queryable << statement }
       else
         raise "@queryable must respond to #<< or be pre-populated with the statements in #{@doap} in a before(:each) block"
@@ -188,11 +190,11 @@ module RDF_Queryable
               its(:count) {should == 2}
 
               it "has two solutions" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_truthy
               end
 
               it "has xi2 as a solution" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_truthy
               end
             end
 
@@ -201,7 +203,7 @@ module RDF_Queryable
               its(:count) {should == 1}
 
               it "has xd1 as a solution" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_truthy
               end
             end
           end
@@ -213,7 +215,7 @@ module RDF_Queryable
     # @see RDF::Queryable#query_execute
     describe "#query_execute" do
       it "defines a protected #query_execute method" do
-        expect(subject.class.protected_method_defined?(:query_execute)).to be_true
+        expect(subject.class.protected_method_defined?(:query_execute)).to be_truthy
       end
 
       context "when called" do
@@ -237,7 +239,7 @@ module RDF_Queryable
     # @see RDF::Queryable#query_pattern
     describe "#query_pattern" do
       it "defines a protected #query_pattern method" do
-        expect(subject.class.protected_method_defined?(:query_pattern)).to be_true
+        expect(subject.class.protected_method_defined?(:query_pattern)).to be_truthy
       end
 
       context "when called" do

data/lib/rdf/spec/reader.rb

@@ -22,7 +22,7 @@ module RDF_Reader
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub(:open_file).and_yield(StringIO.new(@reader_input))
+        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new(@reader_input))
       end
 
       it "yields reader given file_name" do

data/lib/rdf/spec/writable.rb

@@ -23,115 +23,102 @@ module RDF_Writable
   
     describe "#<<" do
       it "inserts a reader" do
-        pending("writability", :unless => subject.writable?) do
-          reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-          subject << reader
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+        subject << reader
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       end
 
       it "inserts a graph" do
-        pending("writability", :unless => subject.writable?) do
-          graph = RDF::Graph.new << @statements
-          subject << graph
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        graph = RDF::Graph.new << @statements
+        subject << graph
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       end
 
       it "inserts an enumerable" do
-        pending("writability", :unless => subject.writable?) do
-          enumerable = @statements.dup.extend(RDF::Enumerable)
-          subject << enumerable
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        enumerable = @statements.dup.extend(RDF::Enumerable)
+        subject << enumerable
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       end
 
       it "inserts data responding to #to_rdf" do
-        pending("writability", :unless => subject.writable?) do
-          mock = double('mock')
-          mock.stub(:to_rdf).and_return(@statements)
-          subject << mock
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        mock = double('mock')
+        allow(mock).to receive(:to_rdf).and_return(@statements)
+        subject << mock
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       end
 
       it "inserts a statement" do
-        pending("writability", :unless => subject.writable?) do
-          subject << statement
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq 1
-        end
+        skip("writability") unless subject.writable?
+        subject << statement
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq 1
       end
 
       it "inserts an invalid statement" do
-        pending("writability", :unless => subject.writable?) do
-          s = RDF::Statement.from([nil, nil, nil])
-          expect(s).not_to  be_valid
-          subject << s
-          expect(subject.count).to eq 1
-        end
+        skip("writability") unless subject.writable?
+        s = RDF::Statement.from([nil, nil, nil])
+        expect(s).not_to  be_valid
+        subject << s
+        expect(subject.count).to eq 1
       end
     end
 
     context "when inserting statements" do
       it "should support #insert" do
-        pending("writability", :unless => subject.writable?) do
-          expect(subject).to respond_to(:insert)
-        end
+        skip("writability") unless subject.writable?
+        expect(subject).to respond_to(:insert)
       end
 
       it "should not raise errors" do
-        pending("writability", :unless => subject.writable?) do
-          expect { subject.insert(statement) }.not_to raise_error
-        end
+        skip("writability") unless subject.writable?
+        expect { subject.insert(statement) }.not_to raise_error
       end
 
       it "should support inserting one statement at a time" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(statement)
-          expect(subject).to have_statement(statement)
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(statement)
+        expect(subject).to have_statement(statement)
       end
 
       it "should support inserting multiple statements at a time" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(*@statements)
       end
 
       it "should insert statements successfully" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(*@statements)
+        expect(subject.count).to eq count
       end
 
       it "should not insert a statement twice" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(statement)
-          subject.insert(statement)
-          expect(subject.count).to eq 1
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(statement)
+        subject.insert(statement)
+        expect(subject.count).to eq 1
       end
 
       it "should treat statements with a different context as distinct" do
-        pending("writability", :unless => subject.writable?) do
-          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_context ? 3 : 1)
-        end
+        skip("writability") unless 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_context ? 3 : 1)
       end
     end
   end

data/lib/rdf/spec/writer.rb

@@ -31,7 +31,7 @@ module RDF_Writer
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new("foo"))
         @dir = Dir.mktmpdir
         @basename = File.join(@dir, "foo")
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-spec
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.5
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,48 +10,62 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
-  type: :runtime
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 description: RDF.rb extension that provides RSpec matchers and shared examples for
@@ -102,12 +116,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []