active-fedora 9.0.2 → 9.0.8

data/lib/active_fedora/file.rb

@@ -1,3 +1,5 @@
+require 'deprecation'
+
 module ActiveFedora
 
   #This class represents a Fedora datastream
@@ -156,21 +158,6 @@ module ActiveFedora
       super || content_changed?
     end
 
-
-    class << self
-      def default_attributes
-        {}
-      end
-    end
-
-    def default_attributes
-      @default_attributes ||= self.class.default_attributes
-    end
-
-    def default_attributes= attributes
-      @default_attributes = default_attributes.merge attributes
-    end
-
     def original_name= name
       @original_name = name
     end

data/lib/active_fedora/inheritable_accessors.rb

@@ -0,0 +1,26 @@
+# Similar to ActiveSupport.class_attribute but with a setter that doesn't use the #{name}= syntax
+# This preserves backward compatibility with the API in ActiveTriples
+
+module ActiveFedora
+  module InheritableAccessors
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def define_inheritable_accessor(*names)
+        names.each do |name|
+          define_accessor(name, nil)
+        end
+      end
+
+      private
+        def define_accessor(name, val)
+          singleton_class.class_eval do
+            remove_possible_method(name)
+            define_method(name) do |uri = nil|
+              define_accessor(name, uri) if uri
+              val
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/nom_datastream.rb

@@ -18,10 +18,6 @@ module ActiveFedora
       @terminology
     end
 
-    def self.default_attributes
-      super.merge(:mimeType => 'text/xml')
-    end
-
     def self.decorate_ng_xml(xml)
       xml.set_terminology terminology_options, &terminology
       xml.nom!
@@ -62,6 +58,12 @@ module ActiveFedora
     def respond_to? *args
       super || self.class.terminology.respond_to?(*args)
     end
+
+    protected
+
+    def default_mime_type
+      'text/xml'
+    end
   end
 end
 

data/lib/active_fedora/rdf/ntriples_rdf_datastream.rb

@@ -2,10 +2,6 @@ require 'rdf/ntriples'
 
 module ActiveFedora
   class NtriplesRDFDatastream < RDFDatastream
-    def self.default_attributes
-      super.merge(:mimeType => 'text/plain')
-    end
-
     def serialization_format
       :ntriples
     end

data/lib/active_fedora/reflection.rb

@@ -152,6 +152,8 @@ module ActiveFedora
             "#{name.to_s.singularize}_ids"
           elsif options[:as]
             "#{options[:as]}_id"
+          elsif inverse_of && inverse_of.collection?
+            "#{options[:inverse_of].to_s.singularize}_ids"
           else
             # This works well if this is a has_many that is the inverse of a belongs_to, but it isn't correct for a has_many that is the invers of a has_and_belongs_to_many
             active_fedora.name.foreign_key
@@ -292,7 +294,7 @@ module ActiveFedora
       # returns either false or the inverse association name that it finds.
       def automatic_inverse_of
         if can_find_inverse_of_automatically?(self)
-          inverse_name = ActiveSupport::Inflector.underscore(active_fedora.name).to_sym
+          inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_fedora.name.demodulize).to_sym
 
           begin
             reflection = klass.reflect_on_association(inverse_name)

data/lib/active_fedora/relation/finder_methods.rb

@@ -38,7 +38,6 @@ module ActiveFedora
       return to_a.find { |*block_args| yield(*block_args) } if block_given?
       options = args.extract_options!
       options = options.dup
-
       cast = if @klass == ActiveFedora::Base && !options.has_key?(:cast)
         true
       else 
@@ -198,12 +197,37 @@ module ActiveFedora
         ActiveFedora::Base
       else
         # The true class may be a subclass of @klass, so always use from_class_uri
-        Model.from_class_uri(has_model_value(resource)) || ActiveFedora::Base
+        resource_class = Model.from_class_uri(has_model_value(resource)) || ActiveFedora::Base
+        unless equivalent_class?(resource_class)
+          raise ActiveFedora::ActiveFedoraError.new("Model mismatch. Expected #{@klass}. Got: #{resource_class}") 
+        end
+        resource_class
       end
     end
 
     def has_model_value(resource)
-      resource.graph.query([nil, ActiveFedora::RDF::Fcrepo::Model.hasModel, nil]).first.object.to_s
+      best_model_match = nil
+
+      resource.graph.query([nil, ActiveFedora::RDF::Fcrepo::Model.hasModel, nil]).each do |rg|
+
+        model_value = Model.from_class_uri(rg.object.to_s)
+
+        if model_value
+
+          best_model_match ||= model_value
+
+          # If there is an inheritance structure, use the most specific case.
+          if best_model_match > model_value
+            best_model_match = model_value
+          end
+        end
+      end
+
+      best_model_match.to_s
+    end
+
+    def equivalent_class?(other_class)
+      other_class <= @klass
     end
 
     def find_with_ids(ids, cast)
@@ -264,10 +288,10 @@ module ActiveFedora
         if value.empty?
           "-#{key}:['' TO *]"
         elsif value.is_a? Array
-          value.map { |val| "#{key}:#{RSolr.escape(val)}" }
+          value.map { |val| "#{key}:#{solr_escape(val)}" }
         else
           key = SOLR_DOCUMENT_ID if (key === :id || key === :id)
-          "#{key}:#{RSolr.escape(value)}"
+          "#{key}:#{solr_escape(value)}"
         end
       end
     end
@@ -283,5 +307,12 @@ module ActiveFedora
       end
     end
 
+
+    private
+      # Adds esaping for spaces which are not handled by RSolr.solr_escape
+      # See rsolr/rsolr#101
+      def solr_escape terms
+        RSolr.solr_escape(terms).gsub(/\s+/,"\\ ")
+      end
   end
 end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "9.0.2"
+  VERSION = "9.0.8"
 end

data/lib/active_fedora/versions_graph.rb

@@ -2,11 +2,13 @@ module ActiveFedora
   class VersionsGraph < ::RDF::Graph
 
     def all opts={}
-      if opts[:include_auto_save]
-        fedora_versions
-      else
-        fedora_versions.reject { |v| v.label.match("auto") }
+      versions = fedora_versions
+      unless opts[:include_auto_save]
+        versions.reject! { |version| version.label.match("auto") }
       end
+      versions.sort_by { |version| DateTime.parse(version.created) }
+    rescue ArgumentError, NoMethodError
+      raise ActiveFedora::VersionLacksCreateDate
     end
 
     def first
@@ -50,10 +52,7 @@ module ActiveFedora
       end
 
       def fedora_versions
-        list = resources.map { |statement| version_from_resource(statement) }
-        list.sort_by(&:created)
+        resources.map { |statement| version_from_resource(statement) }
       end
-
   end
-
 end

data/spec/integration/associations_spec.rb

@@ -24,6 +24,37 @@ describe ActiveFedora::Base do
     end
 
   end
+  
+  describe "explicit foreign key" do
+    before do
+      class FooThing < ActiveFedora::Base
+        has_many :bars, :class_name=>'BarThing', :predicate=>ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, as: :foothing
+      end
+
+      class BarThing < ActiveFedora::Base
+        belongs_to :foothing, :class_name=>'FooThing', :predicate=>ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
+      end
+    end
+    
+    after do
+      Object.send(:remove_const, :FooThing)
+      Object.send(:remove_const, :BarThing)
+    end
+    
+    let(:foo) { FooThing.create }
+    let(:bar) { BarThing.create }
+    
+    it "should associate from bar to foo" do
+      bar.foothing = foo
+      bar.save
+      expect(foo.bars).to eq [bar]
+    end
+    
+    it "should associate from foo to bar" do
+      foo.bars << bar
+      expect(bar.foothing).to eq foo
+    end
+  end
 
   describe "complex example" do
     before do
@@ -255,6 +286,39 @@ describe ActiveFedora::Base do
       end
     end
 
+    describe "when fetching an existing object" do
+      before do
+        class Dog < ActiveFedora::Base; end
+        class BigDog < Dog; end
+        class Cat < ActiveFedora::Base; end
+        @dog = Dog.create
+        @big_dog = BigDog.create
+      end
+      it "should detect class mismatch" do
+        expect {
+          Cat.find @dog.id
+        }.to raise_error(ActiveFedora::ActiveFedoraError)
+      end
+
+      it "should not accept parent class into a subclass" do
+        expect {
+          BigDog.find @dog.id
+        }.to raise_error(ActiveFedora::ActiveFedoraError)
+      end
+
+      it "should accept a subclass into a parent class" do
+        # We could prevent this altogether since loading a subclass into
+        # a parent class (a BigDog into a Dog) would result in lost of 
+        # data if the object is saved back and the subclass has more 
+        # properties than the parent class. However, it does seem reasonable 
+        # that people might want to use them interchangeably (after all  
+        # a BigDog is a Dog) and therefore we allow for it.
+        expect {
+          Dog.find @big_dog.id
+        }.not_to raise_error    
+      end
+    end
+
     describe "setting belongs_to" do
       before do
         @library = Library.new()
@@ -527,27 +591,6 @@ describe ActiveFedora::Base do
         expect(MediaObject.new.association(:baubles).send(:find_reflection)).to eq MediaObject.reflect_on_association(:baubles)
       end
     end
-
-    describe "an object doesn't have a property" do
-      before :all do
-        class Bauble < ActiveFedora::Base
-          belongs_to :media_object, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf
-        end
-
-        class MediaObject < ActiveFedora::Base
-          has_many :shoes
-        end
-      end
-
-      after :all do
-        Object.send(:remove_const, :Bauble)
-        Object.send(:remove_const, :MediaObject)
-      end
-
-      it "it should find the predicate" do
-        expect { MediaObject.new.shoes.send(:find_predicate) }.to raise_error RuntimeError, "No :predicate attribute was set or could be inferred for has_many :shoes on MediaObject"
-      end
-    end
   end
 
   describe "casting when the class name is ActiveFedora::Base" do

data/spec/integration/belongs_to_association_spec.rb

@@ -10,6 +10,9 @@ describe ActiveFedora::Base do
       belongs_to :library, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.hasConstituent
     end
     class SpecialInheritedBook < Book
+      def assert_content_model
+        self.has_model = [self.class.to_s, self.class.superclass.to_s]
+      end
     end
 
   end
@@ -73,8 +76,8 @@ describe ActiveFedora::Base do
     end
 
     it "should cast to the most specific class for the association" do
-      @library2.books[0].class == Book
-      @library2.books[1].class == SpecialInheritedBook
+      expect(@library2.books[0]).to be_instance_of Book
+      expect(@library2.books[1]).to be_instance_of SpecialInheritedBook
     end
 
     after do
@@ -90,104 +93,172 @@ describe ActiveFedora::Base do
         belongs_to :complex_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexCollection'
       end
 
-      class ComplexObject < SimpleObject
+      #NOTE: As RDF assertions seem to be returned in alphabetical order, the "Z" is to insure this is stored
+      # after the SimpleObject relationship for this particular case. This is to ensure people don't just change ActiveFedora
+      # to pick the first content model and it works by alphabetical chance.
+      class ZComplexObject < SimpleObject
         belongs_to :simple_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleCollection'
         belongs_to :complex_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexCollection'
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
       end
 
       class SimpleCollection < ActiveFedora::Base
         has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexObject', autosave: true
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
       end
 
       class ComplexCollection < SimpleCollection
         has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SimpleObject', autosave: true
-        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ComplexObject', autosave: true
+        has_many :complex_objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'ZComplexObject', autosave: true
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
       end
 
     end
     after :all do
       Object.send(:remove_const, :SimpleObject)
-      Object.send(:remove_const, :ComplexObject)
+      Object.send(:remove_const, :ZComplexObject)
       Object.send(:remove_const, :SimpleCollection)
       Object.send(:remove_const, :ComplexCollection)
     end
 
     describe "saving between the before and after hooks" do
+      let(:complex_object) { ZComplexObject.find(ZComplexObject.create.id) }
+      let(:complex_collection) { ComplexCollection.find(ComplexCollection.create.id) }
+
+      context "Verify that an inherited object will save and retrieve with the correct models" do
+        it "should have added the inverse relationship for the correct class" do
+          expect(complex_object.has_model).to match_array(["SimpleObject", "ZComplexObject"])
+          expect(complex_collection.has_model).to match_array(["SimpleCollection", "ComplexCollection"])
+        end
+      end
+
       context "Add a complex_object into a simple_collection" do
+        let(:simple_collection) { SimpleCollection.create }
+
         before do
-          @simple_collection = SimpleCollection.create
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @simple_collection.objects = [@complex_object]
-          @simple_collection.save!
-          @complex_collection.save!
+          simple_collection.objects = [complex_object]
+          simple_collection.save!
+          complex_collection.save!
         end
         it "should have added the inverse relationship for the correct class" do
-          expect(@complex_object.simple_collection).to be_instance_of SimpleCollection
-          expect(@complex_object.complex_collection).to be_nil
+          expect(complex_object.simple_collection).to be_instance_of SimpleCollection
+          expect(complex_object.complex_collection).to be_nil
         end
       end
 
       context "Add a complex_object into a complex_collection" do
         before do
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @complex_collection.objects = [@complex_object] # this sticks it into the :objects association, but since it is a ComplexObject it should also be fetched by :complex_collection association
-          @complex_collection.save
+          complex_collection.objects = [complex_object] # this sticks it into the :objects association, but since it is a ZComplexObject it should also be fetched by :complex_collection association
+          complex_collection.save
         end
 
         it "should have added the inverse relationship for the correct class" do
-          expect(@complex_object.complex_collection).to be_instance_of ComplexCollection
-          expect(@complex_object.reload.simple_collection).to be_instance_of ComplexCollection
+          expect(complex_object.complex_collection).to be_instance_of ComplexCollection
+          expect(complex_object.reload.simple_collection).to be_instance_of ComplexCollection
         end
       end
 
       context "Adding mixed types on a base class with a filtered has_many relationship" do
+        let(:simple_collection) { SimpleCollection.create }
+        let(:simple_object) { SimpleObject.create }
+       
         before do
-          @simple_collection = SimpleCollection.create
-          @complex_object = ComplexObject.create
-          @simple_object = SimpleObject.create
-          @simple_collection.objects = [@complex_object, @simple_object]
-          @simple_collection.save!
+          simple_collection.objects = [complex_object, simple_object]
+          simple_collection.save!
         end
         it "ignores objects who's classes aren't specified" do
-          expect(@simple_collection.complex_objects.size).to eq 1
-          expect(@simple_collection.complex_objects[0]).to be_instance_of ComplexObject
-          expect(@simple_collection.complex_objects[1]).to be_nil
+          expect(simple_collection.complex_objects.size).to eq 1
+          expect(simple_collection.complex_objects[0]).to be_instance_of ZComplexObject
+          expect(simple_collection.complex_objects[1]).to be_nil
 
-          expect(@simple_collection.objects.size).to eq 2
-          expect(@simple_collection.objects[0]).to be_instance_of ComplexObject
-          expect(@simple_collection.objects[1]).to be_instance_of SimpleObject
+          expect(simple_collection.objects.size).to eq 2
+          expect(simple_collection.objects[0]).to be_instance_of ZComplexObject
+          expect(simple_collection.objects[1]).to be_instance_of SimpleObject
 
-          expect(@simple_object.simple_collection).to be_instance_of SimpleCollection
-          expect(@simple_object.complex_collection).to be_nil
+          expect(simple_object.simple_collection).to be_instance_of SimpleCollection
+          expect(simple_object.complex_collection).to be_nil
         end
       end
 
       context "Adding mixed types on a subclass with a filtered has_many relationship" do
-        before do
-          @complex_collection = ComplexCollection.create
-          @complex_object = ComplexObject.create
-          @simple_object = SimpleObject.create
-          @complex_collection.objects = [@complex_object, @simple_object]
-          @complex_collection.save!
+       let(:simple_object) { SimpleObject.create }
+       
+       before do
+          complex_collection.objects = [complex_object, simple_object]
+          complex_collection.save!
         end
         it "ignores objects who's classes aren't specified" do
-          expect(@complex_collection.complex_objects.size).to eq 1
-          expect(@complex_collection.complex_objects[0]).to be_instance_of ComplexObject
-          expect(@complex_collection.complex_objects[1]).to be_nil
+          expect(complex_collection.complex_objects.size).to eq 1
+          expect(complex_collection.complex_objects[0]).to be_instance_of ZComplexObject
+          expect(complex_collection.complex_objects[1]).to be_nil
 
-          expect(@complex_collection.objects.size).to eq 2
-          expect(@complex_collection.objects[0]).to be_instance_of ComplexObject
-          expect(@complex_collection.objects[1]).to be_instance_of SimpleObject
+          expect(complex_collection.objects.size).to eq 2
+          expect(complex_collection.objects[0]).to be_instance_of ZComplexObject
+          expect(complex_collection.objects[1]).to be_instance_of SimpleObject
 
-          expect(@simple_object.complex_collection).to be_instance_of ComplexCollection
-          expect(@simple_object.reload.simple_collection).to be_instance_of ComplexCollection
+          expect(simple_object.complex_collection).to be_instance_of ComplexCollection
+          expect(simple_object.reload.simple_collection).to be_instance_of ComplexCollection
         end
       end
     end
   end
+
+  describe "casting inheritance super class test cases" do
+    before :all do
+      class SuperclassObject < ActiveFedora::Base
+        belongs_to :superclass_collection, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassCollection'
+
+        def assert_content_model
+          self.has_model = [self.class.to_s, self.class.superclass.to_s]
+        end
+      end
+
+      class SubclassObject < SuperclassObject
+      end
+
+      class SuperclassCollection < ActiveFedora::Base
+        has_many :objects, predicate: ActiveFedora::RDF::Fcrepo::RelsExt.isPartOf, class_name: 'SuperclassObject', autosave: true
+      end
+    end
+    after :all do
+      Object.send(:remove_const, :SuperclassObject)
+      Object.send(:remove_const, :SubclassObject)
+      Object.send(:remove_const, :SuperclassCollection)
+    end
+
+    describe "Adding subclass objects" do
+      let(:superclass_collection) { SuperclassCollection.create }
+      let(:superclass_object) { SubclassObject.create }
+
+      context "Add a subclass_object into a superclass_collection" do
+        before do
+          superclass_collection.objects = [subclass_object]
+          superclass_collection.save!
+        end
+        it "should have added the inverse relationship for the correct class" do
+          expect(subclass_object.superclass_collection).to be_instance_of SuperclassCollection
+        end
+      end
+
+      context "Set the superclass_collection of a subclass object"
+        let(:subclass_object) { SubclassObject.create }
+
+        before do
+          subclass_object.superclass_collection = superclass_collection
+          subclass_object.save!
+        end
+        it "should have added the inverse relationship for the correct class" do
+          expect(superclass_collection.objects.size).to eq 1
+          expect(superclass_collection.objects[0]).to be_instance_of SubclassObject
+        end
+      end
+    end
 end