active-fedora 6.8.0 → 7.0.0.pre1

data/spec/unit/rdf_datastream_spec.rb

@@ -2,19 +2,12 @@
 require 'spec_helper'
 
 describe ActiveFedora::RDFDatastream do
-  describe 'a new instance' do
-    describe '#metadata?' do
-      subject { super().metadata? }
-      it { is_expected.to be_truthy}
-    end
-
-    describe '#content_changed?' do
-      subject { super().content_changed? }
-      it { is_expected.to be_falsey}
-    end
+  describe "a new instance" do
+    its(:metadata?) { should be_true}
+    its(:content_changed?) { should be_false}
   end
   describe "an instance that exists in the datastore, but hasn't been loaded" do
-    before do
+    before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
           map.title(in: RDF::DC)
@@ -33,43 +26,43 @@ describe ActiveFedora::RDFDatastream do
       Object.send(:remove_const, :MyDatastream)
       Object.send(:remove_const, :MyObj)
     end
-    subject { @obj.reload.descMetadata }
-    it 'should not load the descMetadata datastream when calling content_changed?' do
-      expect(@obj.inner_object.repository).not_to receive(:datastream_dissemination).with(hash_including(:dsid => 'descMetadata'))
-      expect(subject).not_to be_content_changed
+    subject { @obj.reload.descMetadata } 
+    it "should not load the descMetadata datastream when calling content_changed?" do
+      @obj.inner_object.repository.should_not_receive(:datastream_dissemination).with(hash_including(:dsid=>'descMetadata'))
+      subject.should_not be_content_changed
     end
 
-    it 'should allow asserting an empty string' do
+    it "should allow asserting an empty string" do
       subject.title = ['']
-      expect(subject.title).to eq([''])
+      subject.title.should == ['']
     end
 
-    describe 'when multivalue: false' do
-      it 'should return single values' do
+    describe "when multivalue: false" do
+      it "should return single values" do
         subject.description = 'my description'
-        expect(subject.description).to eq('my description')
+        subject.description.should == 'my description'
       end
     end
 
-    it 'should clear stuff' do
+    it "should clear stuff" do
       subject.title = ['one', 'two', 'three']
       subject.title.clear
-      expect(subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first).to be_nil
+      subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first.should be_nil
     end
 
-    it 'should have a list of fields' do
-      expect(MyDatastream.fields).to eq([:title, :description])
+    it "should have a list of fields" do
+      MyDatastream.fields.should == [:title, :description]
     end
   end
 
-  describe 'deserialize' do
-    it 'should be able to handle non-utf-8 characters' do
+  describe "deserialize" do
+    it "should be able to handle non-utf-8 characters" do
       # see https://github.com/ruby-rdf/rdf/issues/142
       ds = ActiveFedora::NtriplesRDFDatastream.new
       data = "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n\xE2\x80\x99 \" .\n".force_encoding('ASCII-8BIT')
-
+      
       result = ds.deserialize(data)
-      expect(result.dump(:ntriples)).to eq("<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n")
+      result.dump(:ntriples).should == "<info:fedora/scholarsphere:qv33rx50r> <http://purl.org/dc/terms/description> \"\\n’ \" .\n"
     end
   end
 end

data/spec/unit/rdf_list_nested_attributes_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::RdfList do
   before :each do
-    class MADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
+    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
       property :MADSScheme
       property :isMemberOfMADSScheme
       property :authoritativeLabel
@@ -18,22 +18,22 @@ describe ActiveFedora::RdfList do
       include ActiveFedora::RdfObject
       rdf_type MADS.TopicElement
       map_predicates do |map|
-        map.elementValue(:in => MADS)
+        map.elementValue(:in=> MADS)
       end
     end
     class TemporalElement
       include ActiveFedora::RdfObject
       rdf_type MADS.TemporalElement
       map_predicates do |map|
-        map.elementValue(:in => MADS)
+        map.elementValue(:in=> MADS)
       end
     end
     class ElementList
       include ActiveFedora::RdfList
-
+      
       map_predicates do |map|
-        map.topicElement(:in => MADS, :to => 'TopicElement', :class_name => 'TopicElement')
-        map.temporalElement(:in => MADS, :to => 'TemporalElement', :class_name => 'TemporalElement')
+        map.topicElement(:in=> MADS, :to =>"TopicElement", :class_name => "TopicElement")
+        map.temporalElement(:in=> MADS, :to =>"TemporalElement", :class_name => "TemporalElement")
       end
       accepts_nested_attributes_for :topicElement, :temporalElement
     end
@@ -44,7 +44,7 @@ describe ActiveFedora::RdfList do
       rdf_subject { |ds| RDF::URI.new(Rails.configuration.id_namespace + ds.pid)}
       map_predicates do |map|
         map.name(:in => MADS, :to => 'authoritativeLabel')
-        map.elementList(:in => MADS, :class_name => 'ElementList')
+        map.elementList(:in => MADS, :class_name=>'ElementList')
         map.externalAuthority(:in => MADS, :to => 'hasExactExternalAuthority')
       end
       accepts_nested_attributes_for :elementList
@@ -57,15 +57,15 @@ describe ActiveFedora::RdfList do
     Object.send(:remove_const, :TemporalElement)
     Object.send(:remove_const, :MADS)
   end
-
-  describe 'nested_attributes' do
-    it 'should insert new nodes into RdfLists (rather than calling .build)' do
+  
+  describe "nested_attributes" do
+    it "should insert new nodes into RdfLists (rather than calling .build)" do
       params = {
         topic: {
-          name: 'Baseball',
-          externalAuthority: 'http://id.loc.gov/authorities/subjects/sh85012026',
+          name: "Baseball",
+          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
           elementList_attributes: [
-            topicElement_attributes: [{ elementValue: 'Baseball' }, elementValue: 'Football']
+            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
           ]
         }
       }
@@ -73,25 +73,25 @@ describe ActiveFedora::RdfList do
       topic = Topic.new(RDF::Graph.new)
       topic.attributes = params[:topic]
       # puts topic.graph.dump(:ntriples)
-      expect(topic.elementList.first.size).to eq(2)
-      expect(topic.elementList.first[0]).to be_kind_of(TopicElement)
-      expect(topic.elementList.first[0].elementValue).to eq(['Baseball'])
-      expect(topic.elementList.first[1]).to be_kind_of(TopicElement)
-      expect(topic.elementList.first[1].elementValue).to eq(['Football'])
+      topic.elementList.first.size.should == 2
+      topic.elementList.first[0].should be_kind_of(TopicElement)
+      topic.elementList.first[0].elementValue.should == ["Baseball"]
+      topic.elementList.first[1].should be_kind_of(TopicElement)
+      topic.elementList.first[1].elementValue.should == ["Football"]
 
       # only one rdf:rest rdf:nil
-      expect(topic.graph.query([nil, RDF.rest, RDF.nil]).size).to eq(1)
+      topic.graph.query([nil, RDF.rest, RDF.nil]).size.should == 1 
     end
-    it 'should insert new nodes of varying types into RdfLists (rather than calling .build)' do
-      # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.
+    it "should insert new nodes of varying types into RdfLists (rather than calling .build)" do
+      # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.  
       # This is a guess, which currently works.
       params = {
         topic: {
-          name: 'Baseball',
-          externalAuthority: 'http://id.loc.gov/authorities/subjects/sh85012026',
+          name: "Baseball",
+          externalAuthority: "http://id.loc.gov/authorities/subjects/sh85012026",
           elementList_attributes: [
-            topicElement_attributes: [{ elementValue: 'Baseball' }, elementValue: 'Football'],
-            temporalElement_attributes: [{elementValue: '1960'}, {elementValue: 'Twentieth Century'}]
+            topicElement_attributes: [{ elementValue: "Baseball" }, elementValue: "Football"],
+            temporalElement_attributes: [{elementValue: "1960"}, {elementValue:"Twentieth Century"}],
           ]
         }
       }
@@ -99,15 +99,15 @@ describe ActiveFedora::RdfList do
       topic = Topic.new(RDF::Graph.new)
       topic.attributes = params[:topic]
       # puts topic.graph.dump(:ntriples)
-      expect(topic.elementList.first.size).to eq(4)
-      expect(topic.elementList.first[0]).to be_kind_of(TopicElement)
-      expect(topic.elementList.first[0].elementValue).to eq(['Baseball'])
-      expect(topic.elementList.first[1]).to be_kind_of(TopicElement)
-      expect(topic.elementList.first[1].elementValue).to eq(['Football'])
-      expect(topic.elementList.first[2]).to be_kind_of(TemporalElement)
-      expect(topic.elementList.first[2].elementValue).to eq(['1960'])
-      expect(topic.elementList.first[3]).to be_kind_of(TemporalElement)
-      expect(topic.elementList.first[3].elementValue).to eq(['Twentieth Century'])
+      topic.elementList.first.size.should == 4
+      topic.elementList.first[0].should be_kind_of(TopicElement)
+      topic.elementList.first[0].elementValue.should == ["Baseball"]
+      topic.elementList.first[1].should be_kind_of(TopicElement)
+      topic.elementList.first[1].elementValue.should == ["Football"]
+      topic.elementList.first[2].should be_kind_of(TemporalElement)
+      topic.elementList.first[2].elementValue.should == ["1960"]
+      topic.elementList.first[3].should be_kind_of(TemporalElement)
+      topic.elementList.first[3].elementValue.should == ["Twentieth Century"]
     end
   end
 end

data/spec/unit/rdf_list_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ActiveFedora::RdfList do
   before :each do
-    class MADS < RDF::Vocabulary('http://www.loc.gov/mads/rdf/v1#')
+    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
       property :complexSubject
       property :authoritativeLabel
       property :elementList
@@ -12,27 +12,27 @@ describe ActiveFedora::RdfList do
     end
     class DemoList < ActiveFedora::RdfxmlRDFDatastream
       map_predicates do |map|
-        map.elementList(:in => MADS, :to => 'elementList', :class_name => 'List')
-      end
-      class List
+        map.elementList(:in => MADS, :to => 'elementList', :class_name=>'List')
+      end 
+      class List 
         include ActiveFedora::RdfList
         map_predicates do |map|
-          map.topicElement(:in => MADS, :to => 'TopicElement', :class_name => 'TopicElement')
-          map.temporalElement(:in => MADS, :to => 'TemporalElement', :class_name => 'TemporalElement')
+          map.topicElement(:in=> MADS, :to =>"TopicElement", :class_name => "TopicElement")
+          map.temporalElement(:in=> MADS, :to =>"TemporalElement", :class_name => "TemporalElement")
         end
-
+          
         class TopicElement
           include ActiveFedora::RdfObject
           rdf_type MADS.TopicElement
-          map_predicates do |map|
-            map.elementValue(:in => MADS)
+          map_predicates do |map|   
+            map.elementValue(:in=> MADS)
           end
         end
         class TemporalElement
           include ActiveFedora::RdfObject
           rdf_type MADS.TemporalElement
-          map_predicates do |map|
-            map.elementValue(:in => MADS)
+          map_predicates do |map|   
+            map.elementValue(:in=> MADS)
           end
         end
       end
@@ -43,41 +43,41 @@ describe ActiveFedora::RdfList do
     Object.send(:remove_const, :MADS)
   end
 
-  describe 'a new list' do
-    let (:ds) { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata')}
+  describe "a new list" do
+    let (:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')}
     subject { ds.elementList.build}
 
-    it 'should insert at the end' do
-      expect(subject).to be_kind_of DemoList::List
-      expect(subject.size).to eq(0)
+    it "should insert at the end" do
+      subject.should be_kind_of DemoList::List
+      subject.size.should == 0
       subject[1] = DemoList::List::TopicElement.new(subject.graph)
-      expect(subject.size).to eq(2)
+      subject.size.should == 2
     end
 
-    it 'should insert at the head' do
-      expect(subject).to be_kind_of DemoList::List
-      expect(subject.size).to eq(0)
+    it "should insert at the head" do
+      subject.should be_kind_of DemoList::List
+      subject.size.should == 0
       subject[0] = DemoList::List::TopicElement.new(subject.graph)
-      expect(subject.size).to eq(1)
+      subject.size.should == 1
     end
 
-    describe 'that has 4 elements' do
+    describe "that has 4 elements" do
       before do
         subject[3] = DemoList::List::TopicElement.new(subject.graph)
-        expect(subject.size).to eq(4)
+        subject.size.should == 4
       end
-      it 'should insert in the middle' do
+      it "should insert in the middle" do
         subject[1] = DemoList::List::TopicElement.new(subject.graph)
-        expect(subject.size).to eq(4)
+        subject.size.should == 4
       end
     end
 
-    describe 'return updated xml' do
-      it 'should be built' do
-        subject[0] = RDF::URI.new 'http://library.ucsd.edu/ark:/20775/bbXXXXXXX6'
+    describe "return updated xml" do
+      it "should be built" do
+        subject[0] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
         subject[1] = DemoList::List::TopicElement.new(ds.graph)
-        subject[1].elementValue = 'Relations with Mexican Americans'
-        subject[2] = RDF::URI.new 'http://library.ucsd.edu/ark:/20775/bbXXXXXXX4'
+        subject[1].elementValue = "Relations with Mexican Americans"
+        subject[2] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
         subject[3] = DemoList::List::TemporalElement.new(ds.graph)
         subject[3].elementValue = "20th century"
         doc = Nokogiri::XML(ds.content)
@@ -94,40 +94,40 @@ describe ActiveFedora::RdfList do
 
   end
 
-  describe 'an empty list' do
-    subject { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true)).elementList.build }
-    it 'should have to_ary' do
-      expect(subject.to_ary).to eq([])
+  describe "an empty list" do
+    subject { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true)).elementList.build } 
+    it "should have to_ary" do
+      subject.to_ary.should == []
     end
   end
 
-  describe 'a list that has a constructed element' do
-    let(:ds) { DemoList.new(double('inner object', :pid => 'foo', :new_record? => true)) }
-    let(:list) { ds.elementList.build }
+  describe "a list that has a constructed element" do
+    let(:ds) { DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true)) }
+    let(:list) { ds.elementList.build } 
     let!(:topic) { list.topicElement.build }
-
-    it 'should have to_ary' do
-      expect(list.to_ary.size).to eq(1)
-      expect(list.to_ary.first.class).to eq(DemoList::List::TopicElement)
+    
+    it "should have to_ary" do
+      list.to_ary.size.should == 1
+      list.to_ary.first.class.should == DemoList::List::TopicElement
     end
 
-    it 'should be able to be cleared' do
+    it "should be able to be cleared" do
       list.topicElement.build
       list.topicElement.build
       list.topicElement.build
-      expect(list.size).to eq(4)
+      list.size.should == 4
       list.clear
-      expect(list.size).to eq(0)
+      list.size.should == 0
     end
   end
 
-  describe 'a list with content' do
+  describe "a list with content" do
     subject do
-      subject = DemoList.new(double('inner object', :pid => 'foo', :new_record? => true), 'descMetadata')
-      subject.content = <<END
+      subject = DemoList.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata')
+      subject.content =<<END
   <rdf:RDF
       xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
-
+      
         <mads:ComplexSubject rdf:about="info:fedora/foo">
           <mads:elementList rdf:parseType="Collection">
             <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
@@ -145,35 +145,35 @@ END
 
       subject
     end
-    it 'should have a subject' do
-      expect(subject.rdf_subject.to_s).to eq('info:fedora/foo')
+    it "should have a subject" do
+      subject.rdf_subject.to_s.should == "info:fedora/foo"
     end
 
     let (:list) { subject.elementList.first }
 
-    it 'should have fields' do
-      expect(list.first).to eq('http://library.ucsd.edu/ark:/20775/bbXXXXXXX6')
-      expect(list[1]).to be_kind_of DemoList::List::TopicElement
-      expect(list[1].elementValue).to eq(['Relations with Mexican Americans'])
-      expect(list[2]).to eq('http://library.ucsd.edu/ark:/20775/bbXXXXXXX4')
-      expect(list[3]).to be_kind_of DemoList::List::TemporalElement
-      expect(list[3].elementValue).to eq(['20th century'])
+    it "should have fields" do
+      list.first.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
+      list[1].should be_kind_of DemoList::List::TopicElement
+      list[1].elementValue.should == ["Relations with Mexican Americans"]
+      list[2].should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
+      list[3].should be_kind_of DemoList::List::TemporalElement
+      list[3].elementValue.should == ["20th century"]
     end
 
-    it 'should have each' do
+    it "should have each" do
       foo = []
       list.each { |n| foo << n.class }
-      expect(foo).to eq([RDF::URI, DemoList::List::TopicElement, RDF::URI, DemoList::List::TemporalElement])
+      foo.should == [RDF::URI, DemoList::List::TopicElement, RDF::URI, DemoList::List::TemporalElement]
     end
 
-    it 'should have to_ary' do
+    it "should have to_ary" do
       ary = list.to_ary
-      expect(ary.size).to eq(4)
-      expect(ary[1].elementValue).to eq(['Relations with Mexican Americans'])
+      ary.size.should == 4
+      ary[1].elementValue.should == ['Relations with Mexican Americans']
     end
 
-    it 'should have size' do
-      expect(list.size).to eq(4)
+    it "should have size" do
+      list.size.should == 4
     end
 
     it "should update fields" do
@@ -189,3 +189,4 @@ END
     end
   end
 end
+

data/spec/unit/rdf_node_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::RdfNode do
-  describe 'inheritance' do
+  describe "inheritance" do
     before do
       class Parent
         include ActiveFedora::RdfObject
@@ -22,14 +22,14 @@ describe ActiveFedora::RdfNode do
       Object.send(:remove_const, :Parent)
     end
 
-    describe 'child class' do
-      it 'should inherit the terms' do
-        expect(Child.config.keys).to eq(['title', 'description'])
+    describe "child class" do
+      it "should inherit the terms" do
+        Child.config.keys.should == ['title', 'description']
       end
     end
-    describe 'parent class' do
-      it 'should not be infected with the child terms' do
-        expect(Parent.config.keys).to eq(['title'])
+    describe "parent class" do
+      it "should not be infected with the child terms" do
+        Parent.config.keys.should == ['title']
       end
     end
   end