rdf-spec 1.1.13 → 1.99.0

data/lib/rdf/spec/format.rb

@@ -17,17 +17,17 @@ RSpec.shared_examples 'an RDF::Format' do
       end
 
       it "detects #{formats.first} using file_name foo.#{ext}" do
-        expect(RDF::Format.for(:file_name => "foo.#{ext}")).to eq formats.first
+        expect(RDF::Format.for(file_name: "foo.#{ext}")).to eq formats.first
       end
 
       it "detects #{formats.first} using file_extension #{ext}" do
-        expect(RDF::Format.for(:file_extension => ext)).to eq formats.first
+        expect(RDF::Format.for(file_extension: ext)).to eq formats.first
       end
     end
 
     RDF::Format.content_types.each do |content_type, formats|
       it "detects #{formats.first} using content_type #{content_type}" do
-        expect(RDF::Format.for(:content_type => content_type)).to eq formats.first
+        expect(RDF::Format.for(content_type: content_type)).to eq formats.first
       end
     end
   end

data/lib/rdf/spec/http_adapter.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 require 'rdf/spec'
 require 'webmock/rspec'
 
@@ -64,19 +65,28 @@ RSpec.shared_examples 'an RDF::HttpAdapter' do
       WebMock.stub_request(:get, uri).to_return(body: "foo", headers: {"Content-Type" => "text/turtle"})
       RDF::Util::File.open_file(uri) do |f|
         expect(f.content_type).to eq "text/turtle"
-        expect(f.charset).to eq Encoding::UTF_8
-        expect(f.content_encoding).to eq "utf-8"
+        expect(f.charset).to eq "utf-8"
         expect(f.external_encoding.to_s.downcase).to eq "utf-8"
         opened.opened
       end
     end
 
-    it "sets content_type and encoding if provided" do
-      WebMock.stub_request(:get, uri).to_return(body: "foo", headers: {"Content-Type" => "text/turtle ; charset=ISO-8859-4"})
+    it "sets content_type and encoding if provided and UTF" do
+      WebMock.stub_request(:get, uri).to_return(body: "foo".force_encoding("UTF-16"), headers: {"Content-Type" => "text/turtle ; charset=UTF-16"})
       RDF::Util::File.open_file(uri) do |f|
         expect(f.content_type).to eq "text/turtle"
-        expect(f.charset).to eq "ISO-8859-4"
-        expect(f.external_encoding.to_s.downcase).to eq "iso-8859-4"
+        expect(f.charset).to eq "utf-16"
+        expect(f.external_encoding.to_s.downcase).to eq "utf-16"
+        opened.opened
+      end
+    end
+
+    it "sets content_type and encoding to UTF-8 if provided and not UTF" do
+      WebMock.stub_request(:get, uri).to_return(body: "foo".force_encoding("ISO-8859-4"), headers: {"Content-Type" => "text/turtle ; charset=ISO-8859-4"})
+      RDF::Util::File.open_file(uri) do |f|
+        expect(f.content_type).to eq "text/turtle"
+        expect(f.charset).to eq "iso-8859-4"
+        expect(f.external_encoding.to_s.downcase).to eq "utf-8"
         opened.opened
       end
     end
@@ -162,6 +172,18 @@ RSpec.shared_examples 'an RDF::HttpAdapter' do
         end
       end
 
+      it "follows 302 to a relative location" do
+        rel = "../etc/doap.ttl"
+
+        WebMock.stub_request(:get, uri).to_return({status: 302, headers: {"Location" => rel}})
+        WebMock.stub_request(:get, RDF::URI(uri).join(rel).to_s).to_return({body: "foo"})
+        RDF::Util::File.open_file(uri) do |f|
+          expect(f.base_uri).to eq RDF::URI(uri).join(rel).to_s
+          expect(f.read).to eq "foo"
+          opened.opened
+        end
+      end
+
       it "raises an IOError for HTTP 4xx status codes" do
         opened.opened
 

data/lib/rdf/spec/indexable.rb

@@ -10,18 +10,16 @@ RSpec.shared_examples 'an RDF::Indexable' do
 
   subject { indexable }
 
-  it {should respond_to(:indexed?)}
-  its(:indexed?) {should == subject.indexed?}
-  it {should respond_to(:index!)}
+  it {is_expected.to respond_to(:indexed?)}
+  it {is_expected.to respond_to(:index!)}
 
-  it "does not raise error on #index! if #indexed?" do
-    expect {subject.index!}.not_to raise_error if subject.indexed?
+  it "returns boolean for #indexed?" do
+    expect(subject.indexed?).to satisfy {|x| x.is_a?(TrueClass) || x.is_a?(FalseClass)}
   end
 
-  it "raises error on #index! if not #indexed?" do
-    expect {subject.index!}.to raise_error unless subject.indexed?
+  it "returns self on #index!" do
+    expect(subject.index!).to be
   end
-
 end
 
 ##

data/lib/rdf/spec/inferable.rb

@@ -3,7 +3,7 @@ require 'rdf/spec'
 RSpec.shared_examples 'an RDF::Inferable' do
   include RDF::Spec::Matchers
 
-  it "should implement specs" #TODO
+  it "is_expected.to implement specs" #TODO
 end
 
 ##

data/lib/rdf/spec/inspects.rb

@@ -0,0 +1,71 @@
+require 'rdf'
+require 'rdf/ntriples'
+# override several inspect functions to improve output for what we're doing
+
+class RDF::Literal
+  def inspect
+    RDF::NTriples::Writer.serialize(self) + " R:L:(#{self.class.to_s.match(/([^:]*)$/)})"
+  end
+end
+
+class RDF::URI
+  def inspect
+    RDF::NTriples::Writer.serialize(self)
+  end
+end
+
+class RDF::Node
+  def inspect
+    RDF::NTriples::Writer.serialize(self) + "(#{object_id})"
+  end
+end
+
+class RDF::Graph
+  def inspect
+    "\n" + dump(RDF.const_defined?(:Turtle) ? :ttl : :ntriples, standard_prefixes: true) + "\n"
+  end
+end
+
+class RDF::Query
+  def inspect
+    "RDF::Query(#{graph_name ? graph_name.to_sxp : 'nil'})#{patterns.inspect}"
+  end
+end
+
+class Array
+  alias_method :inspect_without_formatting, :inspect
+  def inspect_with_formatting
+    if all? { |item| item.is_a?(Hash) }
+      string = "[\n"
+      each do |item|
+        string += "  {\n"
+          item.keys.map(&:to_s).sort.each do |key|
+            string += "      #{key}: #{item[key.to_sym].inspect}\n"
+          end
+        string += "  },\n"
+      end
+      string += "]"
+      string
+    elsif all? { |item| item.is_a?(RDF::Query::Solution)}
+      string = "[\n"
+      each do |item|
+        string += "  {\n"
+          item.bindings.keys.map(&:to_s).sort.each do |key|
+            string += "      #{key}: #{item.bindings[key.to_sym].inspect}\n"
+          end
+        string += "  },\n"
+      end
+      string += "]"
+      string
+    else
+      inspect_without_formatting
+    end
+  end
+  alias_method :inspect, :inspect_with_formatting
+end
+
+class RDF::Query::Solutions
+  def inspect
+    string = "vars: #{variable_names.join(",")}\n#{to_a.inspect}"
+  end
+end

data/lib/rdf/spec/literal.rb

@@ -7,7 +7,7 @@
 
 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 equality', value, value
   include_examples 'RDF::Literal lexical values', value
 end
 
@@ -69,13 +69,14 @@ 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
+      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|
+  pairs.each do |value, str, human = nil|
+    human ||= value
     klass = RDF::Literal.datatyped_class(datatype.to_s)
 
     it "does not normalize '#{value}' by default" do
@@ -85,18 +86,18 @@ shared_examples 'RDF::Literal canonicalization' do |datatype, pairs|
         .to eq value
     end
 
-    it "normalizes double '#{value}' to '#{str}'" do
+    it "normalizes '#{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
+    it "humanizes '#{value}' to '#{str}'" do
       expect(RDF::Literal.new(value,
                               datatype: datatype,
                               canonicalize: false).humanize)
-        .to eq value
+        .to eq human
     end
 
     it "instantiates '#{value}' as #{klass}" do

data/lib/rdf/spec/matchers.rb

@@ -34,6 +34,10 @@ module RDF; module Spec
       end
     end
 
+    RSpec::Matchers.define :match_triple_pattern do |*pattern|
+      match { |queryable| not queryable.first(pattern).nil? }
+    end
+
     RSpec::Matchers.define :be_mutable do
       match do |enumerable|
         expect(enumerable).to be_a_kind_of(RDF::Mutable)
@@ -256,3 +260,20 @@ module RDF; module Spec
     end
   end # Matchers
 end; end # RDF::Spec
+
+
+module RSpec
+  module Matchers
+    class MatchArray
+      private
+      def safe_sort(array)
+        case
+          when array.all?{|item| item.respond_to?(:<=>) && !item.is_a?(Hash)}
+            array.sort
+          else
+            array
+        end
+      end
+    end
+  end
+end

data/lib/rdf/spec/mutable.rb

@@ -8,11 +8,11 @@ RSpec.shared_examples 'an RDF::Mutable' do
     raise 'mutable must be defined with let(:mutable)' unless
       defined? mutable
 
-    @supports_context = mutable.respond_to?(:supports?) && mutable.supports?(:context)
+    @supports_named_graphs = mutable.respond_to?(:supports?) && mutable.supports?(:graph_name)
   end
 
   let(:resource) { RDF::URI('http://rubygems.org/gems/rdf') }
-  let(:context) { RDF::URI('http://example.org/context') }
+  let(:graph_name) { RDF::URI('http://example.org/graph_name') }
 
   describe RDF::Mutable do
     subject { mutable }
@@ -31,51 +31,60 @@ RSpec.shared_examples 'an RDF::Mutable' do
       it_behaves_like 'an RDF::Writable'
     end
 
-    it {should be_empty}
-    it {should be_readable}
-    it {should be_writable}
-    it {should be_mutable}
-    it {should_not be_immutable}
-    it {should respond_to(:load)}
-    it {should respond_to(:clear)}
-    it {should respond_to(:delete)}
+    it {is_expected.to be_empty}
+    it {is_expected.to be_readable}
+    it {is_expected.to be_writable}
+    it {is_expected.to be_mutable}
+    it {is_expected.to_not be_immutable}
+    it {is_expected.to respond_to(:load)}
+    it {is_expected.to respond_to(:clear)}
+    it {is_expected.to respond_to(:delete)}
 
-    its(:count) {should be_zero}
+    its(:count) {is_expected.to be_zero}
 
     context "#load" do
-      it "should require an argument" do
+      it "is_expected.to require an argument" do
         expect { subject.load }.to raise_error(ArgumentError)
       end
 
-      it "should accept a string filename argument" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
+      it "is_expected.to accept a string filename argument" do
+        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error if subject.mutable?
       end
 
-      it "should accept an optional hash argument" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
+      it "is_expected.to accept an optional hash argument" do
+        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error if subject.mutable?
       end
 
-      it "should load statements" do
-        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)
+      it "is_expected.to load statements" do
+        if subject.mutable?
+          subject.load RDF::Spec::TRIPLES_FILE
+          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
+          is_expected.to have_subject(resource)
+        end
       end
 
-      it "should load statements with a context override" do
-        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
+      it "is_expected.to load statements with a context override", unless: RDF::VERSION.to_s >= "1.99" do
+        if subject.mutable? && @supports_named_graphs
+          subject.load RDF::Spec::TRIPLES_FILE, context: graph_name
+          is_expected.to have_context(graph_name)
+          expect(subject.query(context: graph_name).size).to eq subject.size
+        end
+      end
+
+      it "is_expected.to load statements with a graph_name override", if: RDF::VERSION.to_s >= "1.99" do
+        if subject.mutable? && @supports_named_graphs
+          subject.load RDF::Spec::TRIPLES_FILE, graph_name: graph_name
+          is_expected.to have_graph(graph_name)
+          expect(subject.query(graph_name: graph_name).size).to eq subject.size
+        end
       end
     end
 
     context "#from_{reader}" do
-      it "should instantiate a reader" do
+      it "is_expected.to instantiate a reader" do
         reader = double("reader")
         expect(reader).to receive(:new).and_return(RDF::Spec.quads.first)
+        allow(RDF::Reader).to receive(:for).and_call_original
         expect(RDF::Reader).to receive(:for).with(:a_reader).and_return(reader)
         subject.send(:from_a_reader)
       end
@@ -87,58 +96,61 @@ RSpec.shared_examples 'an RDF::Mutable' do
         subject.insert(*@statements)
       end
 
-      it "should not raise errors" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.delete(@statements.first) }.not_to raise_error
+      it "is_expected.to not raise errors" do
+        expect { subject.delete(@statements.first) }.not_to raise_error if subject.mutable?
       end
 
-      it "should support deleting one statement at a time" do
-        skip("mutability") unless subject.mutable?
-        subject.delete(@statements.first)
-        expect(subject).not_to  have_statement(@statements.first)
+      it "is_expected.to support deleting one statement at a time" do
+        if subject.mutable?
+          subject.delete(@statements.first)
+          is_expected.not_to  have_statement(@statements.first)
+        end
       end
 
-      it "should support deleting multiple statements at a time" do
-        skip("mutability") unless subject.mutable?
-        subject.delete(*@statements)
-        expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+      it "is_expected.to support deleting multiple statements at a time" do
+        if subject.mutable?
+          subject.delete(*@statements)
+          expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+        end
       end
 
-      it "should support wildcard deletions" do
-        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
+      it "is_expected.to support wildcard deletions" do
+        if subject.mutable?
+          # nothing deleted
+          require 'digest/sha1'
+          count = subject.count
+          subject.delete([nil, nil, Digest::SHA1.hexdigest(File.read(__FILE__))])
+          is_expected.not_to  be_empty
+          expect(subject.count).to eq count
+
+          # everything deleted
+          subject.delete([nil, nil, nil])
+          is_expected.to be_empty
+        end
       end
 
-      it "should only delete statements when the context matches" do
-        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)
+      it "is_expected.to only delete statements when the graph_name matches" do
+        if subject.mutable?
+          # Setup three statements identical except for graph_name
+          count = subject.count + (@supports_named_graphs ? 3 : 1)
+          s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
+          s2 = s1.dup
+          s2.graph_name = RDF::URI.new("urn:graph_name:1")
+          s3 = s1.dup
+          s3.graph_name = RDF::URI.new("urn:graph_name: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_named_graphs ? 1 : 1)
+          subject.delete(s2)
+          expect(subject.count).to eq count - (@supports_named_graphs ? 2 : 1)
+          subject.delete(s3)
+          expect(subject.count).to eq count - (@supports_named_graphs ? 3 : 1)
+        end
       end
     end
   end