active-fedora 7.0.0.rc2 → 7.0.0.rc3

data/spec/integration/load_from_solr_spec.rb

@@ -3,22 +3,20 @@ require 'spec_helper'
 describe "Loading from solr" do
   before do
     class MyRdfDatastream < ActiveFedora::NtriplesRDFDatastream
-      map_predicates do |map|
-        map.title(in: RDF::DC) do |index|
-          index.as :stored_searchable, :facetable
-        end
-        map.date_uploaded(to: "dateSubmitted", in: RDF::DC) do |index|
-          index.type :date
-          index.as :stored_searchable, :sortable
-        end
-        map.identifier(in: RDF::DC) do |index|
-          index.type :integer
-          index.as :stored_searchable, :sortable
-        end
-        map.part(to: "hasPart", in: RDF::DC)
-        map.based_near(in: RDF::FOAF)
-        map.related_url(to: "seeAlso", in: RDF::RDFS)
+      property :title, predicate: RDF::DC.title do |index|
+        index.as :stored_searchable, :facetable
       end
+      property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index|
+        index.type :date
+        index.as :stored_searchable, :sortable
+      end
+      property :identifier, predicate: RDF::DC.identifier do |index|
+        index.type :integer
+        index.as :stored_searchable, :sortable
+      end
+      property :part, predicate: RDF::DC.hasPart
+      property :based_near, predicate: RDF::FOAF.based_near
+      property :related_url, predicate: RDF::RDFS.seeAlso
     end
     class MyOmDatastream < ActiveFedora::OmDatastream
       set_terminology do |t|
@@ -48,13 +46,13 @@ describe "Loading from solr" do
   end
 
   it "should be able to get indexed properties without loading from fedora" do
-    expect(RdfTest.connection_for_pid('1')).to receive(:datastream_dissemination).never
+    RdfTest.connection_for_pid('1').should_not_receive(:datastream_dissemination)
     obj = RdfTest.load_instance_from_solr original.pid
     expect(obj.title).to eq "PLAN 9 FROM OUTER SPACE"
     expect(obj.date_uploaded).to eq [Date.parse('1959-01-01')]
     expect(obj.identifier).to eq 12345
     expect{obj.part}.to raise_error KeyError, "Tried to fetch `part' from solr, but it isn't indexed."
-    expect(ActiveFedora::DatastreamAttribute.logger).to receive(:info).with "Couldn't get duck out of solr, because the datastream 'MyOmDatastream' doesn't respond to 'primary_solr_name'. Trying another way."
+    ActiveFedora::DatastreamAttribute.logger.should_receive(:info).with "Couldn't get duck out of solr, because the datastream 'MyOmDatastream' doesn't respond to 'primary_solr_name'. Trying another way."
     expect(obj.duck).to eq 'quack'
   end
 

data/spec/integration/ntriples_datastream_spec.rb

@@ -8,25 +8,23 @@ describe ActiveFedora::NtriplesRDFDatastream do
     end
 
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      map_predicates do |map|
-        map.title(in: RDF::DC) do |index|
-          index.as :stored_searchable, :facetable
-        end
-        map.date_uploaded(to: "dateSubmitted", in: RDF::DC) do |index|
-          index.type :date
-          index.as :stored_searchable, :sortable
-        end
-        map.size(in: FileVocabulary) do |index|
-          index.type :integer
-          index.as :stored_sortable
-        end
-        map.part(to: "hasPart", in: RDF::DC)
-        map.based_near(in: RDF::FOAF)
-        map.related_url(to: "seeAlso", in: RDF::RDFS)
+      property :title, predicate: RDF::DC.title do |index|
+        index.as :stored_searchable, :facetable
       end
+      property :date_uploaded, predicate: RDF::DC.dateSubmitted do |index|
+        index.type :date
+        index.as :stored_searchable, :sortable
+      end
+      property :size, predicate: FileVocabulary.size do |index|
+        index.type :integer
+        index.as :stored_sortable
+      end
+      property :part, predicate: RDF::DC.hasPart
+      property :based_near, predicate: RDF::FOAF.based_near
+      property :related_url, predicate: RDF::RDFS.seeAlso
     end
     class RdfTest < ActiveFedora::Base 
-      has_metadata :name=>'rdf', :type=>MyDatastream
+      has_metadata 'rdf', type: MyDatastream
       has_attributes :based_near, :related_url, :part, :date_uploaded, datastream: 'rdf', multiple: true
       has_attributes :title, :size, datastream: 'rdf', multiple: false
     end
@@ -48,7 +46,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
   end
 
   it "should save content properly upon save" do
-    foo = RdfTest.new(:pid=>'test:1') #Pid needs to match the subject in the loaded file
+    foo = RdfTest.new(pid: 'test:1') #Pid needs to match the subject in the loaded file
     foo.title = 'Hamlet'
     foo.save
     foo.title.should == 'Hamlet'
@@ -154,10 +152,8 @@ describe ActiveFedora::NtriplesRDFDatastream do
       # reopening existing class
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         rdf_subject { |ds| RDF::URI.new("http://oregondigital.org/ns/#{ds.pid.split(':')[1]}") }
-        map_predicates do |map|
-          map.type(:in => RDF::DC)
-          map.spatial(:in => RDF::DC)
-        end
+        property :type, predicate: RDF::DC.type
+        property :spatial, predicate: RDF::DC.spatial
       end
     end
     after do
@@ -212,10 +208,10 @@ describe ActiveFedora::NtriplesRDFDatastream do
   describe "term proxy methods" do
     before(:each) do
       class TitleDatastream < ActiveFedora::NtriplesRDFDatastream
-        map_predicates { |map| map.title(:in => RDF::DC) }
+        property :title, predicate: RDF::DC.title
       end
       class Foobar < ActiveFedora::Base 
-        has_metadata :name=>'rdf', :type=>TitleDatastream
+        has_metadata 'rdf', type: TitleDatastream
         has_attributes :title, datastream: 'rdf', multiple: true
       end
       @subject = Foobar.new

data/spec/integration/om_datastream_spec.rb

@@ -161,7 +161,7 @@ describe ActiveFedora::OmDatastream do
         @obj.reload
       end
       it "should solrize terms with :type=>'date' to *_dt solr terms" do
-        @obj.to_solr[ActiveFedora::SolrService.solr_name('journal_issue_publication_date', type: :date)].should == ['2012-11-02T00:00:00Z']
+        @obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)].should == ['2012-11-02T00:00:00Z']
       end
     end
   end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "Nesting attribute behavior of RDFDatastream" do
   describe ".attributes=" do
     describe "complex properties" do
-      before do 
+      before do
         class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
           # componentList and Types of components
           property :componentList
@@ -12,8 +12,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
           property :PersonalName
           property :CorporateName
           property :ComplexSubject
-          
-          
+
+
           # elementList and elementList values
           property :elementList
           property :elementValue
@@ -25,48 +25,35 @@ describe "Nesting attribute behavior of RDFDatastream" do
         end
 
         class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
-          map_predicates do |map|
-            map.topic(in: DummyMADS, to: "Topic", class_name:"Topic")
-            map.personalName(in: DummyMADS, to: "PersonalName", class_name:"PersonalName")
-            map.title(in: RDF::DC)
-          end
+          property :topic, predicate: DummyMADS.Topic, class_name: "Topic"
+          property :personalName, predicate: DummyMADS.PersonalName, class_name: "PersonalName"
+          property :title, predicate: RDF::DC.title
+
 
           accepts_nested_attributes_for :topic, :personalName
 
-          class Topic
-            include ActiveFedora::RdfObject
-            map_predicates do |map|
-              map.elementList(in: DummyMADS, class_name:"ComplexRDFDatastream::ElementList")
-            end
+          class Topic < ActiveFedora::Rdf::Resource
+            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexRDFDatastream::ElementList"
             accepts_nested_attributes_for :elementList
           end
-          class PersonalName
-            include ActiveFedora::RdfObject
-            map_predicates do |map|
-              map.elementList(in: DummyMADS, to: "elementList", class_name:"ComplexRDFDatastream::ElementList")
-              map.extraProperty(in: DummyMADS, to: "elementValue", class_name:"ComplexRDFDatastream::Topic")
-            end
+          class PersonalName < ActiveFedora::Rdf::Resource
+            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexRDFDatastream::ElementList"
+            property :extraProperty, predicate: DummyMADS.elementValue, class_name: "ComplexRDFDatastream::Topic"
             accepts_nested_attributes_for :elementList, :extraProperty
           end
-          class ElementList
-            include ActiveFedora::RdfList
-            rdf_type DummyMADS.elementList
-            map_predicates do |map|
-              map.topicElement(in: DummyMADS, to: "TopicElement", :class_name => "MadsTopicElement")
-              map.temporalElement(in: DummyMADS, to: "TemporalElement")
-              map.fullNameElement(in: DummyMADS, to: "FullNameElement")
-              map.dateNameElement(in: DummyMADS, to: "DateNameElement")
-              map.nameElement(in: DummyMADS, to: "NameElement")
-              map.elementValue(in: DummyMADS)
-            end
+          class ElementList < ActiveFedora::Rdf::List
+            configure type: DummyMADS.elementList
+            property :topicElement, predicate: DummyMADS.TopicElement, class_name: "ComplexRDFDatastream::MadsTopicElement"
+            property :temporalElement, predicate: DummyMADS.TemporalElement
+            property :fullNameElement, predicate: DummyMADS.FullNameElement
+            property :dateNameElement, predicate: DummyMADS.DateNameElement
+            property :nameElement, predicate: DummyMADS.NameElement
+            property :elementValue, predicate: DummyMADS.elementValue
             accepts_nested_attributes_for :topicElement
           end
-          class MadsTopicElement
-            include ActiveFedora::RdfObject
-            rdf_type DummyMADS.TopicElement
-            map_predicates do |map|
-              map.elementValue(in: DummyMADS)
-            end
+          class MadsTopicElement < ActiveFedora::Rdf::Resource
+            configure :type => DummyMADS.TopicElement
+            property :elementValue, predicate: DummyMADS.elementValue
           end
         end
       end
@@ -75,8 +62,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
         Object.send(:remove_const, :DummyMADS)
       end
       subject { ComplexRDFDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
-      let(:params) do 
-        { myResource: 
+      let(:params) do
+        { myResource:
           {
             topic_attributes: {
               '0' =>
@@ -93,12 +80,12 @@ describe "Nesting attribute behavior of RDFDatastream" do
               }
             },
             personalName_attributes: [
-              { 
+              {
                 elementList_attributes: [{
                   fullNameElement: "Jefferson, Thomas",
-                  dateNameElement: "1743-1826"                  
+                  dateNameElement: "1743-1826"
                 }]
-              } 
+              }
               #, "Hemings, Sally"
             ],
           }
@@ -106,7 +93,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       end
 
       describe "on lists" do
-        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) } 
+        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
         it "should accept a hash" do
           subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
           subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
@@ -121,43 +108,37 @@ describe "Nesting attribute behavior of RDFDatastream" do
       end
 
       it "should create nested objects" do
-          # Replace the graph's contents with the Hash
-          subject.attributes = params[:myResource]
-
-          # Here's how this would happen if we didn't have attributes=
-          # personal_name = subject.personalName.build 
-          # elem_list = personal_name.elementList.build
-          # elem_list.fullNameElement = "Jefferson, Thomas"
-          # elem_list.dateNameElement = "1743-1826"
-          # topic = subject.topic.build
-          # elem_list = topic.elementList.build
-          # elem_list.fullNameElement = 'Cosmology'
-
-          subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
-          subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
-          subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
-          subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
+        # Replace the graph's contents with the Hash
+        subject.attributes = params[:myResource]
+
+        # Here's how this would happen if we didn't have attributes=
+        # personal_name = subject.personalName.build
+        # elem_list = personal_name.elementList.build
+        # elem_list.fullNameElement = "Jefferson, Thomas"
+        # elem_list.dateNameElement = "1743-1826"
+        # topic = subject.topic.build
+        # elem_list = topic.elementList.build
+        # elem_list.fullNameElement = 'Cosmology'
+        subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
+        subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
+        subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
+        subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
       end
     end
 
     describe "with an existing object" do
-      before(:each) do 
+      before(:each) do
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-          map_predicates do |map|
-            map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
-          end
+          property :parts, predicate: RDF::DC.hasPart, :class_name=>'Component'
           accepts_nested_attributes_for :parts, allow_destroy: true
 
-          class Component
-            include ActiveFedora::RdfObject
-            map_predicates do |map|
-              map.label(:in=> RDF::DC, :to=>'title')
-            end
+          class Component < ActiveFedora::Rdf::ObjectResource
+            property :label, predicate: RDF::DC.title
           end
         end
 
       end
-      
+
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
@@ -180,8 +161,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
       end
       it "create a new object when the id is provided" do
        subject.parts_attributes= [{id: 'http://example.com/part#1', label: "Universal Joint"}]
-       subject.parts.last.rdf_subject.should == 'http://example.com/part#1'
+       expect(subject.parts.last.rdf_subject).to eq RDF::URI('http://example.com/part#1')
       end
-    end    
+    end
   end
 end

data/spec/integration/relation_spec.rb

@@ -13,29 +13,42 @@ describe ActiveFedora::Base do
     Object.send(:remove_const, :Book)
   end
 
-  subject {Library.all} 
+  subject { Library.all } 
   its(:class) {should eq ActiveFedora::Relation }
 
-  describe "#find" do
+  before :all do
+    Library.create
+    @library = Library.create
+  end
+
+  let(:library1) { @library }
+
+  describe "is cached" do
     before do
-      Library.create
-      @library = Library.create
+      subject.to_a # trigger initial load
+    end
+
+    it "should be loaded" do
+      expect(subject).to be_loaded
     end
+    it "shouldn't reload" do
+      ActiveFedora::Relation.any_instance.should_not_receive :find_each
+      subject[0]
+    end
+  end
+
+  describe "#find" do
     it "should find one of them" do
-      expect(subject.find(@library.id)).to eq @library
+      expect(subject.find(library1.id)).to eq library1
     end
     it "should find with a block" do
-      expect(subject.find { |l| l.id == @library.id}).to eq @library
+      expect(subject.find { |l| l.id == library1.id}).to eq library1
     end
   end
 
   describe "#select" do
-    before do
-      Library.create
-      @library = Library.create
-    end
     it "should find with a block" do
-      expect(subject.select { |l| l.id == @library.id}).to eq [@library]
+      expect(subject.select { |l| l.id == library1.id}).to eq [library1]
     end
   end
 end

data/spec/integration/scoped_query_spec.rb

@@ -81,8 +81,12 @@ describe "scoped queries" do
         ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1).should == [test_instance2]
       end
 
+      it "should wrap string conditions with parentheses" do
+        ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values.should == ["(foo:bar OR bar:baz)"]
+      end
+
       it "should chain where queries" do
-        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where(ActiveFedora::SolrService.solr_name('foo', type: :string) => 'bar').where_values.should == {ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts', ActiveFedora::SolrService.solr_name('foo', type: :string) => 'bar'}
+        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values.should == ["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"]
       end
 
       it "should chain count" do

data/spec/samples/hydra-mods_article_datastream.rb

@@ -153,6 +153,10 @@ module Hydra
       end
       return builder.doc
     end
+
+    def prefix
+      "#{dsid.underscore}__"
+    end
     
     # Generates a new Person node
     def self.person_template

data/spec/samples/hydra-rights_metadata_datastream.rb

@@ -79,6 +79,11 @@ module Hydra
       end
       return builder.doc
     end
+
+    def prefix
+      "#{dsid.underscore}__"
+    end
+
     
     # Returns the permissions for the selected person/group
     # If new_access_level is provided, updates the selected person/group access_level to the one specified 

data/spec/samples/marpa-dc_datastream.rb

@@ -92,6 +92,11 @@ module Marpa
       end
       return builder.doc
     end
+
+    def prefix
+      "#{dsid.underscore}__"
+    end
+
   
   end
-end
+end

data/spec/samples/special_thing.rb

@@ -21,15 +21,15 @@ class SpecialThing < ActiveFedora::Base
   # This declares a datastream with Datastream ID (dsid) of "descMetadata"
   # The descMetadata datastream is bound to the Hydra::ModsArticleDatastream class that's defined in lib/active_fedora/samples
   # Any time you load a Fedora object using an instance of SampleModel, the instance will assume its descMetadata datastream conforms to the assumptions in Hydra::ModsArticleDatastream class
-  has_metadata :name => "descMetadata", :type=> Hydra::ModsArticleDatastream
+  has_metadata "descMetadata", type: Hydra::ModsArticleDatastream
   
   # This declares a datastream with Datastream ID (dsid) of "rightsMetadata"
   # Like the descMetadata datastream, any time you load a Fedora object using an instance of SampleModel, the instance will assume its descMetadata datastream conforms to the assumptions in Hydra::RightsMetadataDatastream class
-  has_metadata :name => "rightsMetadata", :type => Hydra::RightsMetadataDatastream
+  has_metadata "rightsMetadata", type: Hydra::RightsMetadataDatastream
   
   # This is not part of the Hydra conventions
   # Adding an extra datastream called "extraMetadataForFun" that is bound to the Marpa::DcDatastream class
-  has_metadata :name => "extraMetadataForFun", :type => Marpa::DcDatastream
+  has_metadata "extraMetadataForFun", type: Marpa::DcDatastream
   
   #
   # RELATIONSHIPS
@@ -37,8 +37,8 @@ class SpecialThing < ActiveFedora::Base
   
   # This is an example of how you can add a custom relationship to a model
   # This will allow you to call .derivation on instances of the model to get the _outbound_ "hasDerivation" relationship in the RELS-EXT datastream
-  belongs_to :derivation, :property=>:has_derivation
+  belongs_to :derivation, property: :has_derivation, class_name: 'SpecialThing' 
 
   # This will allow you to call .inspirations on instances of the model to get a list of all of the objects that assert "hasDerivation" relationships pointing at this object
-  has_many :inspirations, :property=>:has_derivation
+  has_many :inspirations, property: :has_derivation, class_name: 'SpecialThing'
 end