rdf-spec 1.1.5 → 1.1.13

data/lib/rdf/spec/inferable.rb

@@ -1,10 +1,23 @@
 require 'rdf/spec'
 
+RSpec.shared_examples 'an RDF::Inferable' do
+  include RDF::Spec::Matchers
+
+  it "should implement specs" #TODO
+end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Inferable"` instead
 module RDF_Inferable
   extend RSpec::SharedContext
   include RDF::Spec::Matchers
 
-  describe RDF::Inferable do
-    it "should implement specs" #TODO
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Inferable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Inferable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Inferable'
   end
 end

data/lib/rdf/spec/literal.rb

@@ -0,0 +1,143 @@
+##
+# Shared examples for RDF::Literals are broken up into multiple example sets.
+#
+# To use the core example sets that apply to most RDF::Literal implementations
+# include the examples for `RDF::Literal`, `RDF::Literal validation`,
+# `RDF::Literal canonicalization`, and `RDF::Literal lookup`.
+
+shared_examples 'RDF::Literal' do |value, datatype_uri|
+  include_examples 'RDF::Literal with datatype and grammar', value, datatype_uri
+  include_examples 'RDF::Literal equality', value
+  include_examples 'RDF::Literal lexical values', value
+end
+
+shared_examples 'RDF::Literal with datatype and grammar' do |value, datatype_uri|
+  include_examples 'RDF::Literal with grammar'
+  include_examples 'RDF::Literal with datatype', value, datatype_uri
+end
+
+shared_examples 'RDF::Literal lexical values' do |value|
+  subject { described_class.new(value) }
+
+  describe '#humanize' do
+    it 'gives a string representation' do
+      expect(subject.humanize).to be_a String
+    end
+  end
+
+  describe '#to_s' do
+    it 'gives a string representation' do
+      expect(subject.to_s).to be_a String
+    end
+  end
+end
+
+shared_examples 'RDF::Literal with grammar' do
+  it 'has a GRAMMAR' do
+    expect(described_class::GRAMMAR).to respond_to :=~
+  end
+end
+
+shared_examples 'RDF::Literal equality' do |value, other|
+  subject { described_class.new(value) }
+
+  describe '#==' do
+    it { is_expected.to eq subject }
+    it { expect(subject.object).to eq (other || value) }
+    it { is_expected.not_to eq described_class.new('OTHER') }
+    it { is_expected.not_to eq nil }
+  end
+end
+
+shared_examples 'RDF::Literal with datatype' do |value, datatype_uri|
+  subject { described_class.new(value) }
+
+  it { is_expected.to be_literal }
+  it { is_expected.to be_typed }
+  it { is_expected.not_to be_plain }
+  it { is_expected.not_to be_anonymous }
+
+  it 'has a DATATYPE' do
+    expect(described_class::DATATYPE).to be_a RDF::URI
+  end
+
+  it 'has correct datatype' do
+    expect(subject.datatype).to eq datatype_uri
+  end
+end
+
+shared_examples 'RDF::Literal lookup' do |uri_hash|
+  uri_hash.each do |uri, klass|
+    it "finds #{klass} for #{uri}" do
+      expect(RDF::Literal("0", :datatype => uri).class).to eq klass
+    end
+  end
+end
+
+shared_examples 'RDF::Literal canonicalization' do |datatype, pairs|
+  pairs.each do |value, str|
+    klass = RDF::Literal.datatyped_class(datatype.to_s)
+
+    it "does not normalize '#{value}' by default" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype ,
+                              canonicalize: false).to_s)
+        .to eq value
+    end
+
+    it "normalizes double '#{value}' to '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true).to_s)
+        .to eq str
+    end
+
+    it "humanizes double '#{value}' to '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: false).humanize)
+        .to eq value
+    end
+
+    it "instantiates '#{value}' as #{klass}" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true))
+        .to be_a(klass)
+    end
+
+    it "causes normalized '#{value}' to be == '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true))
+        .to eq RDF::Literal.new(str, datatype: datatype, canonicalize: false)
+    end
+  end
+end
+
+shared_examples 'RDF::Literal validation' do |datatype,
+                                              valid_values,
+                                              invalid_values|
+
+  klass = RDF::Literal.datatyped_class(datatype.to_s)
+
+  valid_values.each do |value|
+    it "validates #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).to be_valid
+    end
+
+    it "does not invalidate #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).not_to be_invalid
+    end
+  end
+
+  invalid_values.each do |value|
+    it "invalidates #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).to be_invalid
+    end
+
+    it "does not validate #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).not_to be_valid
+    end
+  end
+end

data/lib/rdf/spec/mutable.rb

@@ -1,39 +1,34 @@
 require 'rdf/spec'
 require 'rdf/ntriples'
 
-module RDF_Mutable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Mutable' do
   include RDF::Spec::Matchers
 
-  before :each do
-    raise '+@mutable+ must be defined in a before(:each) block' unless instance_variable_get('@mutable')
+  before do
+    raise 'mutable must be defined with let(:mutable)' unless
+      defined? mutable
 
-    @supports_context = @mutable.respond_to?(:supports?) && @mutable.supports?(:context)
+    @supports_context = mutable.respond_to?(:supports?) && mutable.supports?(:context)
   end
-  let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
-  let(:context) {RDF::URI('http://example.org/context')}
+
+  let(:resource) { RDF::URI('http://rubygems.org/gems/rdf') }
+  let(:context) { RDF::URI('http://example.org/context') }
 
   describe RDF::Mutable do
-    subject {@mutable}
+    subject { mutable }
 
     context "readability" do
       require 'rdf/spec/readable'
 
-      before :each do
-        @readable = @mutable
-      end
-
-      include RDF_Readable
+      let(:readable) { mutable }
+      it_behaves_like 'an RDF::Readable'
     end
 
     context "writability" do
       require 'rdf/spec/writable'
 
-      before :each do
-        @writable = @mutable
-      end
-
-      include RDF_Writable
+      let(:writable) { mutable }
+      it_behaves_like 'an RDF::Writable'
     end
 
     it {should be_empty}
@@ -80,7 +75,7 @@ module RDF_Mutable
     context "#from_{reader}" do
       it "should instantiate a reader" do
         reader = double("reader")
-        expect(reader).to receive(:new).and_return(RDF::NTriples::Reader.new(""))
+        expect(reader).to receive(:new).and_return(RDF::Spec.quads.first)
         expect(RDF::Reader).to receive(:for).with(:a_reader).and_return(reader)
         subject.send(:from_a_reader)
       end
@@ -148,3 +143,25 @@ module RDF_Mutable
     end
   end
 end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Mutable"` instead
+module RDF_Mutable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Mutable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Mutable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Mutable' do
+      let(:mutable) { @mutable }
+
+      before do
+        raise '@mutable must be defined' unless defined?(mutable)
+      end
+    end
+  end
+end

data/lib/rdf/spec/queryable.rb

@@ -1,28 +1,28 @@
 require 'rdf/spec'
 
-module RDF_Queryable
-  extend RSpec::SharedContext
+RSpec.shared_examples 'an RDF::Queryable' do
   include RDF::Spec::Matchers
 
   before :each do
-    raise '+@queryable+ must be defined in a before(:each) block' unless instance_variable_get('@queryable')
+    raise 'querable must be set with `let(:queryable)' unless
+      defined? queryable
 
     @doap = RDF::Spec::QUADS_FILE
     @statements = RDF::Spec.quads
 
-    if @queryable.empty?
-      if (@queryable.writable? rescue false)
-        @queryable.insert(*@statements)
-      elsif @queryable.respond_to?(:<<)
-        @statements.each { |statement| @queryable << statement }
+    if queryable.empty?
+      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"
+        raise "queryable must respond to #<< or be pre-populated with the statements in #{@doap} in a before(:each) block"
       end
     end
   end
 
   describe RDF::Queryable do
-    subject {@queryable}
+    subject {queryable}
     let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
     let(:literal) {RDF::Literal.new('J. Random Hacker')}
     let(:query) {RDF::Query.new {pattern [:s, :p, :o]}}
@@ -186,24 +186,37 @@ module RDF_Queryable
           # From data-r2/expr-equals
           context "data/r2/expr-equals" do
             context "graph-1" do
-              subject {@queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Integer.new(1)).to_a}
-              its(:count) {should == 2}
+              let(:result) do
+                queryable.query(:predicate => RDF::URI("http://example.org/p"),
+                                :object => RDF::Literal::Integer.new(1)).to_a
+              end
 
-              it "has two solutions" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_truthy
+              it 'has two solutions' do
+                expect(result.count).to eq 2
+              end
+
+              it "has xi1 as a solution" do
+                expect(result.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_truthy
+                expect(result.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_truthy
               end
             end
 
             context "graph-2" do
-              subject {@queryable.query(:predicate => RDF::URI("http://example.org/p"), :object => RDF::Literal::Double.new("1.0e0")).to_a}
-              its(:count) {should == 1}
+              let(:result) do
+                queryable.query(:predicate => RDF::URI("http://example.org/p"),
+                                :object => RDF::Literal::Double.new("1.0e0"))
+                  .to_a
+              end
+
+              it 'has one solution' do
+                expect(result.count).to eq 1
+              end
 
               it "has xd1 as a solution" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_truthy
+                expect(result.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_truthy
               end
             end
           end
@@ -224,7 +237,7 @@ module RDF_Queryable
         end
 
         it "yields to the given block" do
-          expect {|b| subject.send(:query_execute, query, &b)}.to yield_control.exactly(@queryable.count).times
+          expect {|b| subject.send(:query_execute, query, &b)}.to yield_control.exactly(queryable.count).times
         end
 
         it "yields solutions" do
@@ -248,7 +261,7 @@ module RDF_Queryable
         end
 
         it "yields to the given block" do
-          expect {|b| subject.send(:query_pattern, RDF::Query::Pattern.new, &b)}.to yield_control.exactly(@queryable.count).times
+          expect {|b| subject.send(:query_pattern, RDF::Query::Pattern.new, &b)}.to yield_control.exactly(queryable.count).times
         end
 
         it "yields statements" do
@@ -256,7 +269,7 @@ module RDF_Queryable
             expect(statement).to be_a_statement
           end
         end
-    
+
         context "with specific patterns" do
           # Note that "01" should not match 1, per data-r2/expr-equal/sameTerm
           {
@@ -317,7 +330,7 @@ module RDF_Queryable
     ##
     # @see RDF::Queryable#first
     describe "#first" do
-      let(:failing_pattern) {[RDF::Node.new] * 3}
+      let(:failing_pattern) {[RDF::URI("http://no-such-resource"), RDF.type, RDF::Node.new]}
 
       it "should respond to #first" do
         expect(subject).to respond_to(:first)
@@ -328,7 +341,7 @@ module RDF_Queryable
         expect(subject.first).to eq subject.each.first # uses an Enumerator
       end
 
-      it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns the correct value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], subject.each.first]
         matching_patterns.each do |matching_pattern|
           expect(subject.first(matching_pattern)).to eq subject.query(matching_pattern).each.first
@@ -349,19 +362,19 @@ module RDF_Queryable
     ##
     # @see RDF::Queryable#first_subject
     describe "#first_subject" do
-      let(:failing_pattern) {[RDF::Node.new, nil, nil]}
+      let(:failing_pattern) {[RDF::URI("http://no-such-resource"), nil, nil]}
 
       it "should respond to #first_subject" do
         expect(subject).to respond_to(:first_subject)
       end
 
-      it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns enumerator without a pattern" do
         expect { subject.first_subject }.not_to raise_error
         expect(subject.first_subject).to eq subject.first.subject
       end
 
-      it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
-        matching_patterns = [[nil, nil, nil], [subject.first.subject, nil, nil]]
+      it "returns the correct value when the pattern matches" do
+        matching_patterns = [[nil, nil, nil], [RDF::URI("http://rubygems.org/gems/rdf"), nil, nil]]
         matching_patterns.each do |matching_pattern|
           expect(subject.first_subject(matching_pattern)).to eq subject.query(matching_pattern).first.subject
         end
@@ -382,16 +395,16 @@ module RDF_Queryable
     # @see RDF::Queryable#first_predicate
 
     describe "#first_predicate" do
-      let(:failing_pattern) {[nil, RDF::Node.new, nil]}
+      let(:failing_pattern) {[nil, RDF::URI("http://no-such-resource"), nil]}
 
       it {should respond_to(:first_predicate)}
 
-      it "returns enumerator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns enumerator without a pattern" do
         expect { subject.first_predicate }.not_to raise_error
         expect(subject.first_predicate).to eq subject.first.predicate
       end
 
-      it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns the correct value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [nil, subject.first.predicate, nil]]
         matching_patterns.each do |matching_pattern|
           expect(subject.first_predicate(matching_pattern)).to eq subject.query(matching_pattern).first.predicate
@@ -413,15 +426,15 @@ module RDF_Queryable
     # @see RDF::Queryable#first_object
 
     describe "#first_object" do
-      let(:failing_pattern) {[nil, nil, RDF::Node.new]}
+      let(:failing_pattern) {[nil, nil, RDF::URI("http://no-such-resource")]}
       it {should respond_to(:first_object)}
 
-      it "returns enurator without a pattern", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns enurator without a pattern" do
         expect { subject.first_object }.not_to raise_error
         expect(subject.first_object).to eq subject.first.object
       end
 
-      it "returns the correct value when the pattern matches", :pending => (defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java') do
+      it "returns the correct value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [nil, nil, subject.first.object]]
         matching_patterns.each do |matching_pattern|
           expect(subject.first_object(matching_pattern)).to eq subject.query(matching_pattern).first.object
@@ -514,3 +527,25 @@ module RDF_Queryable
     end
   end
 end
+
+##
+# @deprecated use `it_behaves_like "an RDF::Queryable"` instead
+module RDF_Queryable
+  extend RSpec::SharedContext
+  include RDF::Spec::Matchers
+
+  def self.included(mod)
+    warn "[DEPRECATION] `RDF_Queryable` is deprecated. "\
+         "Please use `it_behaves_like 'an RDF::Queryable'`"
+  end
+
+  describe 'examples for' do
+    include_examples 'an RDF::Queryable' do
+      let(:queryable) { @queryable }
+
+      before do
+        raise '@queryable must be defined' unless defined?(queryable)
+      end
+    end
+  end
+end