Modernize specs.

Author: gkellogg

lib/rdf/spec/countable.rb

@@ -24,22 +24,22 @@
   describe RDF::Countable do
     subject {countable}
 
-    it {should respond_to(:empty?)}
-    it {should_not be_empty}
-    it {should respond_to(:count)}
-    its(:count) {should == @statements.size}
-    it {should respond_to(:size)}
-    its(:size) {should == @statements.size}
+    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}
+    it {is_expected.to respond_to(:size)}
+    its(:size) {is_expected.to eq @statements.size}
 
     context "when empty" do
       subject {[].extend(RDF::Countable)}
-      it {should be_empty}
-      its(:count) {should == 0}
-      its(:size) {should == 0}
+      it {is_expected.to be_empty}
+      its(:count) {is_expected.to eq 0}
+      its(:size) {is_expected.to eq 0}
     end
 
-    its(:to_enum) {should be_countable}
-    its(:enum_for) {should be_countable}
+    its(:to_enum) {is_expected.to be_countable}
+    its(:enum_for) {is_expected.to be_countable}
     it "#enum_for(:each)" do
       expect(subject.enum_for(:each)).to be_countable
     end

lib/rdf/spec/durable.rb

@@ -27,21 +27,21 @@
 
   subject {@load_durable.call}
 
-  it { should respond_to(:durable?) }
+  it { is_expected.to respond_to(:durable?) }
 
-  it "should support #durable?" do
+  it "is_expected.to support #durable?" do
     expect([true,false]).to be_member(subject.durable?)
   end
 
-  it {should respond_to(:nondurable?)}
+  it {is_expected.to respond_to(:nondurable?)}
 
-  it "should support #nondurable?" do
+  it "is_expected.to support #nondurable?" do
     expect([true,false]).to be_member(@load_durable.call.nondurable?)
   end
 
-  its(:nondurable?) {should_not == subject.durable?}
+  its(:nondurable?) {is_expected.to_not eq subject.durable?}
 
-  it "should save contents between instantiations" do
+  it "is_expected.to save 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