active-fedora 5.2.1 → 5.3.0

data/Gemfile

@@ -10,4 +10,4 @@ group :development, :test do
 end
 
 gem 'jruby-openssl', :platform=> :jruby
-gem 'nom-xml', :git => 'git://github.com/cbeer/nom-xml.git'
+gem 'nom-xml', '>=0.5.1'

data/active-fedora.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.add_dependency("activesupport", '>= 3.0.0')
   s.add_dependency("builder", '~> 3.0.0')
   s.add_dependency("mediashelf-loggable")
-  s.add_dependency("rubydora", '~>1.0')
+  s.add_dependency("rubydora", '~>1.2')
   s.add_dependency("rdf")
   s.add_dependency("rdf-rdfxml", '~>0.3.8')
   s.add_dependency("deprecation")

data/lib/active_fedora/base.rb

@@ -304,7 +304,6 @@ module ActiveFedora
         solrize_profile(solr_doc)
       end
       datastreams.each_value do |ds|
-        ds.ensure_xml_loaded if ds.respond_to? :ensure_xml_loaded  ### Can't put this in the model because it's often implemented in Solrizer::XML::TerminologyBasedSolrizer 
         solr_doc = ds.to_solr(solr_doc)
       end
       solr_doc = solrize_relationships(solr_doc) unless opts[:model_only]

data/lib/active_fedora/datastream.rb

@@ -5,7 +5,7 @@ module ActiveFedora
     extend Deprecation
     attr_writer :digital_object
     attr_accessor :last_modified, :fields
-  
+
     def initialize(digital_object=nil, dsid=nil, options={})
       ## When you use the versions feature of rubydora (0.5.x), you need to have a 3 argument constructor
       self.fields={}

data/lib/active_fedora/delegating.rb

@@ -59,7 +59,7 @@ module ActiveFedora
         define_method field do
           ds = self.send(args[:to])
           val = if ds.kind_of?(ActiveFedora::RDFDatastream)
-                  ds.send(:get_values, field)
+                  ds.send(field)
                 else
                   terminology = args[:at] || [field]
                   ds.send(:term_values, *terminology)
@@ -72,7 +72,7 @@ module ActiveFedora
         define_method "#{field}=".to_sym do |v|
           ds = self.send(args[:to])
           if ds.kind_of?(ActiveFedora::RDFDatastream)
-            ds.send(:set_value, field, v)
+            ds.send("#{field}=", v)
           else
             terminology = args[:at] || [field]
             ds.send(:update_indexed_attributes, {terminology => v})

data/lib/active_fedora/nokogiri_datastream.rb

@@ -5,20 +5,24 @@ require "solrizer/xml"
 #this class represents a xml metadata datastream
 module ActiveFedora
   class NokogiriDatastream < Datastream
-      
-    before_save do
-      return unless xml_loaded
-      content_will_change! if ng_xml_changed?
-    end  
 
+    before_save do
+      if content.blank?
+        logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
+        false
+      end
+    end
+    
+      extend Deprecation
+  #  include MetadataDatastreamHelper
     include OM::XML::Document
     include Solrizer::XML::TerminologyBasedSolrizer # this adds support for calling .to_solr
     
     alias_method(:om_term_values, :term_values) unless method_defined?(:om_term_values)
     alias_method(:om_update_values, :update_values) unless method_defined?(:om_update_values)
     
-    attr_accessor :internal_solr_doc, :xml_loaded
-
+    attr_accessor :internal_solr_doc
+    
     def self.default_attributes
       super.merge(:controlGroup => 'X', :mimeType => 'text/xml')
     end
@@ -47,16 +51,8 @@ module ActiveFedora
       Nokogiri::XML::Document.parse("<xml/>")
     end
 
-    def save
-      @content = to_xml if ng_xml_changed? and content_will_change!
-      super
-    end
-
-
     def ng_xml 
       @ng_xml ||= begin
-      self.xml_loaded = true
-
       if new?
         ## Load up the template
         self.class.xml_template
@@ -67,26 +63,16 @@ module ActiveFedora
     end
     
     def ng_xml=(new_xml)
-
-      nokogiri_document = case new_xml 
+      case new_xml 
       when Nokogiri::XML::Document
-        new_xml
+        @ng_xml = new_xml
       when  Nokogiri::XML::Node 
-        Nokogiri::XML(new_xml.to_s) ## Cast a fragment to a document
+        @ng_xml = Nokogiri::XML(new_xml.to_s) ## Cast a fragment to a document
       when String 
-        Nokogiri::XML::Document.parse(new_xml)
+        @ng_xml = Nokogiri::XML::Document.parse(new_xml)
       else
         raise TypeError, "You passed a #{new_xml.class} into the ng_xml of the #{self.dsid} datastream. NokogiriDatastream.ng_xml= only accepts Nokogiri::XML::Document, Nokogiri::XML::Element, Nokogiri::XML::Node, or raw XML (String) as inputs."
       end
-
-
-      new_xml_string = nokogiri_document.to_xml {|config| config.no_declaration}
-
-      ng_xml_will_change! unless (xml_loaded && (new_xml_string.to_s.strip == (datastream_content || '').strip))
-      self.xml_loaded=true
-
-      @ng_xml = nokogiri_document
-
     end
     
     # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
@@ -100,27 +86,7 @@ module ActiveFedora
     
     # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
     def ng_xml_changed?
-      return true if changed_attributes.has_key?('ng_xml')
-
-      return false unless xml_loaded
-
-      if new?
-        !to_xml.empty?
-      else
-       (to_xml.strip != (datastream_content || '').strip)
-     end
-    end
-
-    def changed?
-      ng_xml_changed? || super
-    end
-
-    def content_changed?
-      ng_xml_changed? || super
-    end
-
-    def has_content?
-      xml_loaded || super
+      changed_attributes.has_key? 'ng_xml'
     end
 
     # Indicates that this datastream has metadata content. 
@@ -129,21 +95,23 @@ module ActiveFedora
       true
     end
 
-    def content=(content)
-      content_will_change! unless (xml_loaded && (content == datastream_content))
-      @content = content
-      self.xml_loaded=true
-      self.ng_xml = Nokogiri::XML::Document.parse(datastream_content)
+    def content
+      to_xml
     end
 
-    alias :datastream_content :content
-
-    def content
-      return to_xml if xml_loaded or new?
-      
-      datastream_content
+    def datastream_content
+      @datastream_content ||= Nokogiri::XML(super).to_xml  {|config| config.no_declaration}.strip
     end
     
+    def content=(content)
+      @ng_xml = Nokogiri::XML::Document.parse(content)
+    end
+
+    def content_changed?
+      return false if new? and !xml_loaded
+      super
+    end
+
     def to_xml(xml = nil)
       xml = self.ng_xml if xml.nil?
       ng_xml = self.ng_xml
@@ -164,7 +132,7 @@ module ActiveFedora
         end
       end
       
-      return xml.to_xml {|config| config.no_declaration}
+      return xml.to_xml {|config| config.no_declaration}.strip
     end
     
     # ** Experimental **
@@ -427,6 +395,18 @@ module ActiveFedora
         om_term_values(*term_pointer)
       end
     end
+
+    # Deprecated methods left here for backwards compatibility
+    def ensure_xml_loaded; end
+    deprecation_deprecate :ensure_xml_loaded
+
+    def serialize!
+    end
+    
+    def xml_loaded
+      instance_variable_defined? :@ng_xml
+    end
+    
   end
 end
 

data/lib/active_fedora/rdf_datastream.rb

@@ -2,10 +2,12 @@ module ActiveFedora
   class RDFDatastream < Datastream
 
     before_save do
-      return unless graph_changed?
-      content_will_change!
-    end  
-
+      if content.blank?
+        logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
+        false
+      end
+    end
+    
     # this enables a cleaner API for solr integration
     class IndexObject
       attr_accessor :data_type, :behaviors
@@ -24,154 +26,173 @@ module ActiveFedora
       end
     end
 
-    module ModelMethods
-      extend ActiveSupport::Concern
-      module ClassMethods
-        attr_accessor :vocabularies
-        def config
-          ActiveFedora::Predicates.predicate_config
-        end
-        def prefix(name)
-          name = name.to_s unless name.is_a? String
-          pre = self.to_s.sub(/RDFDatastream$/i, '').underscore
-          return "#{pre}__#{name}".to_sym
-        end
-
-        ##
-        # Register a ruby block that evaluates to the subject of the graph
-        # By default, the block returns the current object's pid
-        # @yield [ds] 'ds' is the datastream instance
-        def rdf_subject &block
-          if block_given?
-             return @subject_block = block
-          end
+    class << self 
+      attr_accessor :vocabularies
+      def config
+        ActiveFedora::Predicates.predicate_config
+      end
+      def prefix(name)
+        name = name.to_s unless name.is_a? String
+        pre = self.to_s.sub(/RDFDatastream$/i, '').underscore
+        return "#{pre}__#{name}".to_sym
+      end
 
-          @subject_block ||= lambda { |ds| "info:fedora/#{ds.pid}" }
+      ##
+      # Register a ruby block that evaluates to the subject of the graph
+      # By default, the block returns the current object's pid
+      # @yield [ds] 'ds' is the datastream instance
+      def rdf_subject &block
+        if block_given?
+           return @subject_block = block
         end
 
-        def register_vocabularies(*vocabs)
-          @vocabularies ||= {}
-          vocabs.each do |v|
-            if v.is_a?(RDF::Vocabulary) or (v.respond_to? :property and v.respond_to? :to_uri)
-              @vocabularies[v.to_uri] = v 
-            else
-              raise "not an RDF vocabulary: #{v}"
-            end
+        @subject_block ||= lambda { |ds| RDF::URI.new("info:fedora/#{ds.pid}") }
+      end
+
+      def register_vocabularies(*vocabs)
+        @vocabularies ||= {}
+        vocabs.each do |v|
+          if v.is_a?(RDF::Vocabulary) or (v.respond_to? :property and v.respond_to? :to_uri)
+            @vocabularies[v.to_uri] = v 
+          else
+            raise "not an RDF vocabulary: #{v}"
           end
-          ActiveFedora::Predicates.vocabularies(@vocabularies)
-          @vocabularies
         end
+        ActiveFedora::Predicates.vocabularies(@vocabularies)
+        @vocabularies
+      end
 
-        def map_predicates(&block)
-          yield self
+      def map_predicates(&block)
+        yield self
+      end
+      def method_missing(name, *args, &block)
+        args = args.first if args.respond_to? :first
+        raise "mapping must specify RDF vocabulary as :in argument" unless args.has_key? :in
+        vocab = args[:in]
+        predicate = args.fetch(:to, name)
+        raise "Vocabulary '#{vocab.inspect}' does not define property '#{predicate.inspect}'" unless vocab.respond_to? predicate
+        indexing = false
+        if block_given?
+          # needed for solrizer integration
+          indexing = true
+          iobj = IndexObject.new
+          yield iobj
+          data_type = iobj.data_type
+          behaviors = iobj.behaviors
         end
-        def method_missing(name, *args, &block)
-          args = args.first if args.respond_to? :first
-          raise "mapping must specify RDF vocabulary as :in argument" unless args.has_key? :in
-          vocab = args[:in]
-          predicate = args.fetch(:to, name)
-          raise "Vocabulary '#{vocab.inspect}' does not define property '#{predicate.inspect}'" unless vocab.respond_to? predicate
-          indexing = false
-          if block_given?
-            # needed for solrizer integration
-            indexing = true
-            iobj = IndexObject.new
-            yield iobj
-            data_type = iobj.data_type
-            behaviors = iobj.behaviors
-          end
-          # needed for AF::Predicates integration & drives all other
-          # functionality below
-          vocab = vocab.to_s
-          name = self.prefix(name)
-          if config
-            if config[:predicate_mapping].has_key? vocab
-              config[:predicate_mapping][vocab][name] = predicate
-            else
-              config[:predicate_mapping][vocab] = { name => predicate } 
-            end
-            # stuff data_type and behaviors in there for to_solr support
-            config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
-            config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
+        # needed for AF::Predicates integration & drives all other
+        # functionality below
+        vocab = vocab.to_s
+        name = self.prefix(name)
+        if config
+          if config[:predicate_mapping].has_key? vocab
+            config[:predicate_mapping][vocab][name] = predicate
           else
-            config = {
-              :default_namespace => vocab,
-              :predicate_mapping => {
-                vocab => { name => predicate }
-              }
-            }
-            # stuff data_type and behaviors in there for to_solr support
-            config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
-            config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
+            config[:predicate_mapping][vocab] = { name => predicate } 
           end
+          # stuff data_type and behaviors in there for to_solr support
+          config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
+          config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
+        else
+          config = {
+            :default_namespace => vocab,
+            :predicate_mapping => {
+              vocab => { name => predicate }
+            }
+          }
+          # stuff data_type and behaviors in there for to_solr support
+          config[:predicate_mapping][vocab]["#{name}__type".to_sym] = data_type if indexing
+          config[:predicate_mapping][vocab]["#{name}__behaviors".to_sym] = behaviors if indexing
         end
       end
     end
+
+
     class TermProxy
-      # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-      # @param [ActiveFedora::RelationshipGraph] graph  the graph
-      # @param [Array] values  an array of object values
-      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
-      
-      def initialize(graph, predicate, values=[])
+
+      attr_reader :graph, :subject, :predicate
+      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :to => :values
+
+      def initialize(graph, subject, predicate)
         @graph = graph
+
+        @subject = subject
         @predicate = predicate
-        @values = values
       end
+
       def <<(*values)
-        @values.concat(values)
-        values.each { |value| @graph.add(@predicate, value, true) }
-        @graph.dirty = true
-        @values
+        values.each { |value| graph.append(subject, predicate, value) }
+        values
       end
+
       def delete(*values)
         values.each do |value| 
-          unless @values.delete(value).nil?
-            @graph.delete(@predicate, value)
-            @graph.dirty = true
-          end
+          graph.delete_predicate(subject, predicate, value)
         end
-        @values
+
+        values
       end
-      def method_missing(method, *args)
-        unless @values.respond_to?(method)
-          message = "undefined method `#{method.to_s}' for \"#{@values}\":#{@values.class.to_s}"
-          raise NoMethodError, message
+
+      def values
+        values = []
+
+        graph.query(subject, predicate).each do |solution|
+          v = solution.value
+          v = v.to_s if v.is_a? RDF::Literal
+          values << v
         end
 
-        if block_given?
-          @values.send(method, *args)  { |*block_args| yield(*block_args) }
+        values
+      end
+      
+      def method_missing(method, *args, &block)
+
+        if values.respond_to? method
+          values.send(method, *args, &block)
         else
-          @values.send(method, *args)
+          super
         end
-  
       end
     end
     
-    include ModelMethods
     attr_accessor :loaded
-
     def metadata?
       true
     end
+    def ensure_loaded
+    end
 
-    def save
-      @content = serialize  if graph_changed? and content_will_change!
-
-      super
+    def content
+      serialize
     end
 
     def content=(content)
-      content_will_change!
       self.loaded = true
       @graph = deserialize(content)
     end
 
+    def content_changed?
+      return false if new? and !loaded
+      super
+    end
+
+    def changed?
+      super || content_changed?
+    end
+
     # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
     def fields
-      
       field_map = {}
-      graph.relationships.each do |predicate, values|
+
+      rdf_subject = self.rdf_subject
+      query = RDF::Query.new do
+        pattern [rdf_subject, :predicate, :value]
+      end
+
+      query.execute(graph).each do |solution|
+        predicate = solution.predicate
+        value = solution.value
+        
         vocab_sym, name = predicate.qname
         uri, vocab = self.class.vocabularies.select { |ns, v| v.__prefix__ == vocab_sym }.first
         next unless vocab
@@ -182,13 +203,13 @@ module ActiveFedora
         next unless name and config.has_key?("#{name}__type".to_sym) and config.has_key?("#{name}__behaviors".to_sym)
         type = config["#{name}__type".to_sym]
         behaviors = config["#{name}__behaviors".to_sym]
-        field_map[name.to_sym] = {:values => values.map {|v| v.to_s}, :type => type, :behaviors => behaviors}
+        field_map[name.to_sym] ||= {:values => [], :type => type, :behaviors => behaviors}
+        field_map[name.to_sym][:values] << value.to_s
       end
       field_map
     end
 
     def to_solr(solr_doc = Hash.new) # :nodoc:
-      
       fields.each do |field_key, field_info|
         values = field_info.fetch(:values, false)
         if values
@@ -215,100 +236,90 @@ module ActiveFedora
     # Assumes that the datastream contains RDF content
     # @param [String] data the "rdf" node 
     def deserialize(data = nil)
-      graph = RelationshipGraph.new
-      return graph if new? and data.nil?
+      repository = RDF::Repository.new
+      return repository if new? and data.nil?
 
       data ||= datastream_content
 
-        RDF::Reader.for(serialization_format).new(data) do |reader|
-          reader.each_statement do |statement|
-            begin
-              next unless statement.subject == rdf_subject
-            rescue
-            end
-            literal = statement.object.kind_of?(RDF::Literal)
-            object = literal ? statement.object.value : statement.object.to_s
-            graph.add(statement.predicate, object, literal)
-          end
+      RDF::Reader.for(serialization_format).new(data) do |reader|
+        reader.each_statement do |statement|
+          repository << statement
         end
+      end
 
-      graph
+      repository
     end
 
     def graph
       @graph ||= begin
         self.loaded = true
         deserialize
-      end
-    end
-
-    # alias the original datastream content
-    alias :datastream_content :content
-
-    def content
-      # return the RDF graph content if it's available (or all we have)
-      return serialize if loaded or new?
-
-      # otherwise, grab the data from the datastore
-      super
+      end      
     end
-    
-    def graph_will_change!
-      changed_attributes['graph'] = nil
-    end
-
-    def graph_changed?
-      return true if changed_attributes.has_key?('graph')
-      return false unless loaded
 
-      if new?
-        !serialize.empty?
-      else
-        serialize.strip != (datastream_content || '').strip
+    def query subject, predicate, &block
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+      
+      q = RDF::Query.new do
+        pattern [subject, predicate, :value]
       end
 
-    end
-
-    def changed?
-       graph_changed? || super
+      q.execute(graph, &block)
     end
 
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def get_values(predicate)
-      
+    def get_values(subject, predicate)
+
       predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-      results = graph[predicate]
-      return if results.nil?
-      values = []
-      results.each do |object|
-        values << (object.kind_of?(RDF::Literal) ? object.value : object.to_s)
-      end
-      TermProxy.new(graph, predicate, values)
+
+      return TermProxy.new(self, subject, predicate)
     end
 
     # if there are any existing statements with this predicate, replace them
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def set_value(predicate, args)
+
+    def set_value(subject, predicate, values)
       
       predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-      graph.delete(predicate)
-      args = [args] unless args.respond_to? :each
-      args.each do |arg|
+
+      delete_predicate(subject, predicate)
+
+      Array(values).each do |arg|
         arg = arg.to_s if arg.kind_of? RDF::Literal
-        graph.add(predicate, arg, true) unless arg.empty?
+        next if arg.empty?
+
+        graph.insert([subject, predicate, arg])
       end
-      graph.dirty = true
-      return TermProxy.new(graph, predicate, args)
+
+      return TermProxy.new(self, subject, predicate)
+    end
+ 
+    def delete_predicate(subject, predicate, values = nil)
+      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
+
+      if values.nil?
+        query = RDF::Query.new do
+          pattern [subject, predicate, :value]
+        end
+
+        query.execute(graph).each do |solution|
+          graph.delete [subject, predicate, solution.value]
+        end
+      else
+        Array(values).each do |v|
+          graph.delete [subject, predicate, v]
+        end
+      end
+
     end
 
     # append a value 
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
-    def append(predicate, args)
-      
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-      graph.add(predicate, args, true)
-      graph.dirty = true
-      return TermProxy.new(graph, predicate, args)
+    def append(subject, predicate, args)
+      graph.insert([subject, predicate, args])
+
+
+      return TermProxy.new(self, subject, predicate)
     end
 
     def serialization_format
@@ -317,29 +328,54 @@ module ActiveFedora
 
     def method_missing(name, *args)
       if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
-        set_value(pred, *args)  
+        set_value(rdf_subject, pred, *args)  
        elsif pred = find_predicate(name)
-        get_values(name)
+        get_values(rdf_subject, name)
       else 
         super
       end
+    rescue ActiveFedora::UnregisteredPredicateError
+      super
     end
 
     ##
     # Get the subject for this rdf/xml datastream
     def rdf_subject
-      @subject ||= self.class.rdf_subject.call(self)
+      @subject ||= begin
+        s = self.class.rdf_subject.call(self)
+        s &&= RDF::URI.new(s) if s.is_a? String
+        s
+      end
     end   
 
+    def reset_rdf_subject!
+      @subject = nil
+    end
+
     # Creates a RDF datastream for insertion into a Fedora Object
     # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
     def serialize
-      out = RDF::Writer.for(serialization_format).buffer do |writer|
-        graph.to_graph(rdf_subject).each_statement do |statement|
-          writer << statement
-        end
+      update_subjects_to_use_a_real_pid!
+      RDF::Writer.for(serialization_format).dump(graph)
+    end
+
+    def update_subjects_to_use_a_real_pid!
+      return unless new?
+
+      bad_subject = rdf_subject
+      reset_rdf_subject!
+      new_subject = rdf_subject
+
+      new_repository = RDF::Repository.new
+
+      graph.each_statement do |statement|
+          subject = statement.subject
+
+          subject &&= new_subject if subject == bad_subject
+          new_repository << [subject, statement.predicate, statement.object]
       end
-      out
+
+      @graph = new_repository
     end
   end
 end

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "5.2.1"
+  VERSION = "5.3.0"
 end

data/spec/integration/datastream_spec.rb

@@ -48,11 +48,11 @@ describe ActiveFedora::Datastream do
     ds.content = fixture('dino.jpg')
     @test_object.add_datastream(ds).should be_true
     @test_object.save
+    @test_object.datastreams[dsid].should_not be_changed
     to = ActiveFedora::Base.find(@test_object.pid) 
     to.should_not be_nil 
     to.datastreams[dsid].should_not be_nil
     to.datastreams[dsid].content.should == fixture('dino.jpg').read
-    
   end
   
   it "should be able to set the versionable attribute" do

data/spec/integration/ntriples_datastream_spec.rb

@@ -26,20 +26,13 @@ describe ActiveFedora::NtriplesRDFDatastream do
     Object.send(:remove_const, :MyDatastream)
   end
 
-  it "should set and recall" do
-    @subject.title = "John Doe"
+  it "should not try to send an empty datastream" do
     @subject.save
-    f = RdfTest.find(@subject.pid)
-    f.title.should == "John Doe"
-    f.title = "Jane Doe"
-    f.save
-    new_object = RdfTest.find(@subject.pid)
-    new_object.title.should == "Jane Doe"
-
   end
 
   it "should set and recall values" do
     @subject.title = 'War and Peace'
+    @subject.rdf.should be_changed
     @subject.based_near = "Moscow, Russia"
     @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
     @subject.part = "this is a part"
@@ -55,6 +48,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.related_url = "http://en.wikipedia.org/wiki/War_and_Peace"
     @subject.part = "this is a part"
     @subject.save
+
     loaded = RdfTest.find(@subject.pid)
     loaded.title.should == 'War and Peace'
     loaded.based_near.should == ['Moscow, Russia']
@@ -82,6 +76,13 @@ describe ActiveFedora::NtriplesRDFDatastream do
     @subject.save
     @subject.title.should be_nil
   end
+
+  it "should be able to save a blank document" do
+    @subject.title = ""
+    @subject.save
+  end
+
+
   it "should delete values" do
     @subject.title = "Hamlet"
     @subject.related_url = "http://psu.edu/"

data/spec/integration/om_datastream_spec.rb

@@ -22,7 +22,6 @@ describe ActiveFedora::OmDatastream do
 
   describe "#changed?" do
     it "should not be changed if the new xml matches the old xml" do
-      
       @pid = "hydrangea:fixture_mods_article2"
       @test_object = HydrangeaArticle2.find(@pid)
 
@@ -30,6 +29,27 @@ describe ActiveFedora::OmDatastream do
 
       @test_object.descMetadata.should_not be_changed
     end
+
+
+    it "should not be changed if there are minor differences in whitespace" do
+
+      obj = HydrangeaArticle2.new
+      obj.descMetadata.content = "<a>1</a>"
+      obj.save
+      obj.descMetadata.should_not be_changed
+      obj.descMetadata.content = "<a>1</a>\n"
+      obj.descMetadata.should_not be_changed
+
+    end
+  end
+
+  describe "empty datastream content" do
+    it "should not break when there is empty datastream content" do
+      obj = HydrangeaArticle2.new
+      obj.descMetadata.content = ""
+      obj.save
+
+    end
   end
 
   describe '.term_values' do

data/spec/unit/datastream_collections_spec.rb

@@ -81,6 +81,12 @@ describe ActiveFedora::DatastreamCollections do
       @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
     end
 
+    it "should  allow access to file content" do
+      @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg",:file=>@f})
+      @test_object2.save!
+      @test_object2.thumbnail[0].content
+    end
+
     it "should raise an error if neither a blob nor file is set" do
       expect { @test_object2.add_named_datastream("thumbnail",{:content_type=>"image/jpeg"}) }.to raise_error
     end

data/spec/unit/datastream_spec.rb

@@ -61,30 +61,6 @@ describe ActiveFedora::Datastream do
     end
   end
   
-  describe '#save' do
-    it "should set changed" do
-      mock_repo = mock('repository')
-      mock_repo.stub(:config).and_return({})
-      mock_repo.stub(:add_datastream).with(:versionable => true, :pid => @test_object.pid, :dsid => 'abcd', :controlGroup => 'M', :dsState => 'A', :content => 'hi there')
-      mock_repo.stub(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return('')
-      @test_object.inner_object.stub(:repository).and_return(mock_repo)
-      @test_datastream.save
-      @test_datastream.should_not be_changed
-    end
-  end
-  
-  describe '.content=' do
-    it "should update the content and ng_xml, marking the datastream as changed" do
-      sample_xml = "<foo><xmlelement/></foo>"
-      @test_datastream.instance_variable_get(:@changed_attributes).clear
-      @test_datastream.should_not be_changed
-      @test_datastream.content.should_not be_equivalent_to(sample_xml)
-      @test_datastream.content = sample_xml
-      @test_datastream.should be_changed
-      @test_datastream.content.should be_equivalent_to(sample_xml)
-    end
-  end
-  
   it "should have mimeType accessors" do
     ds1 = ActiveFedora::Datastream.new
     ds1.mimeType = "text/foo"

data/spec/unit/ntriples_datastream_spec.rb

@@ -53,7 +53,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.created.should be_kind_of Array
     end
     it "should have method missing" do
-      lambda{@subject.frank}.should raise_exception ActiveFedora::UnregisteredPredicateError
+      lambda{@subject.frank}.should raise_exception NoMethodError
     end
 
     it "should set fields" do
@@ -69,7 +69,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.publisher.should == ["Penn State", "St. Martin's Press"]
     end
     it "should delete fields" do
-      @subject.related_url.delete("http://google.com/")
+      @subject.related_url.delete(RDF::URI("http://google.com/"))
       @subject.related_url.should == []
     end
   end
@@ -166,10 +166,10 @@ describe ActiveFedora::NtriplesRDFDatastream do
           map.rights(:in => RDF::DC)
         end
       end
-    end
-    before(:each) do
       @subject = MyDatastream.new(@inner_object, 'solr_rdf')
       @subject.content = File.new('spec/fixtures/solr_rdf_descMetadata.nt').read
+    end
+    before(:each) do  
       @subject.stub(:pid => 'test:1')
       @subject.stub(:new? => false)
       @sample_fields = {:my_datastream__publisher => {:values => ["publisher1"], :type => :string, :behaviors => [:facetable, :sortable, :searchable, :displayable]}, 
@@ -272,15 +272,6 @@ describe ActiveFedora::NtriplesRDFDatastream do
         @obj.save
       end
 
-      describe '.content=' do
-        it "should update the content and graph, marking the datastream as changed" do
-          sample_rdf = File.new('spec/fixtures/mixed_rdf_descMetadata.nt').read
-          @obj.stub(:new? => false)
-          @obj.should_not be_changed
-          @obj.content = sample_rdf
-          @obj.should be_changed
-        end
-      end
       it "should save content properly upon save" do
         foo = Foo.new(:pid => 'test:1')
         foo.title = 'Hamlet'

data/spec/unit/om_datastream_spec.rb

@@ -22,6 +22,7 @@ describe ActiveFedora::OmDatastream do
     @test_ds = ActiveFedora::OmDatastream.new(@mock_inner, "descMetadata")
     @test_ds.stub(:new? => false, :profile => {}, :datastream_content => '<test_xml/>')
     @test_ds.content="<test_xml/>"
+    @test_ds.stub(:new? => false)
   end
   
   after(:each) do
@@ -46,6 +47,7 @@ describe ActiveFedora::OmDatastream do
     it "should initialize from #xml_template if no xml is provided" do
       ActiveFedora::OmDatastream.should_receive(:xml_template).and_return("<fake template/>")
       n = ActiveFedora::OmDatastream.new
+      n.ensure_xml_loaded
       n.ng_xml.should be_equivalent_to("<fake template/>")
     end
   end
@@ -158,15 +160,6 @@ describe ActiveFedora::OmDatastream do
       @mods_ds.get_values("--my xpath--").should == ["abstract1", "abstract2"]
     end
   end
-  
-  describe '#from_xml' do
-    it "should work when a template datastream is passed in" do
-      mods_xml = Nokogiri::XML::Document.parse( fixture(File.join("mods_articles", "hydrangea_article1.xml")) )
-      tmpl = Hydra::ModsArticleDatastream.new
-      Hydra::ModsArticleDatastream.from_xml(mods_xml,tmpl).ng_xml.root.to_xml.should == mods_xml.root.to_xml
-    end
-  end
-  
 
   it 'should provide .fields' do
     @test_ds.should respond_to(:fields)
@@ -177,6 +170,7 @@ describe ActiveFedora::OmDatastream do
       @test_ds.should respond_to(:save)
     end
     it "should persist the product of .to_xml in fedora" do
+      @mock_repo.stub(:datastream).and_return('')
       @test_ds.stub(:new? => true)
       @test_ds.stub(:to_xml => "fake xml")
       @mock_repo.should_receive(:add_datastream).with(:pid => nil, :dsid => 'descMetadata', :versionable => true, :content => 'fake xml', :controlGroup => 'X', :dsState => 'A', :mimeType=>'text/xml')
@@ -192,11 +186,11 @@ describe ActiveFedora::OmDatastream do
     it "should update the content" do
       subject.stub(:new? => false )
       subject.content = "<a />"
-      subject.datastream_content.should == '<a />'
+      subject.content.should == '<a/>'
     end
 
     it "should mark the object as changed" do
-      subject.stub(:new? => false )
+      subject.stub(:new? => false, :controlGroup => 'M')
       subject.content = "<a />"
       subject.should be_changed
     end
@@ -211,6 +205,7 @@ describe ActiveFedora::OmDatastream do
   
   describe 'ng_xml=' do
     before do
+      @mock_inner.stub(:new? => true)
       @test_ds2 = ActiveFedora::OmDatastream.new(@mock_inner, "descMetadata")
     end
     it "should parse raw xml for you" do
@@ -225,9 +220,9 @@ describe ActiveFedora::OmDatastream do
       @test_ds2.ng_xml.to_xml.should be_equivalent_to("<xmlelement/>")
     end
     it "should mark the datastream as changed" do
+      @test_ds2.stub(:new? => false, :controlGroup => 'M')
       @test_ds2.should_not be_changed 
       @test_ds2.ng_xml = @sample_raw_xml
-      @test_ds2.ng_xml_changed?.should be_true
       @test_ds2.should be_changed
       @test_ds2.instance_variable_get(:@content).should be_nil
     end
@@ -240,7 +235,7 @@ describe ActiveFedora::OmDatastream do
     
     it "should ng_xml.to_xml" do
       @test_ds.stub(:ng_xml => Nokogiri::XML::Document.parse("<text_document/>"))
-      @test_ds.to_xml.should == "<text_document/>\n"       
+      @test_ds.to_xml.should == "<text_document/>"       
     end
     
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -53,16 +53,6 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
 
   end
 
-  it "should parse dcterms and dcelements from xml" do
-    doc = Nokogiri::XML::Document.parse(File.open( File.dirname(__FILE__)+'/../fixtures/changeme155.xml') )
-    stream = doc.xpath('//foxml:datastream[@ID=\'dublin_core\']/foxml:datastreamVersion/foxml:xmlContent/dc')
-    ds = ActiveFedora::QualifiedDublinCoreDatastream.new
-    n = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(stream.to_xml, ds)
-    n.spatial.should == ["Boston [7013445]", "Dorchester [7013575]", "Roxbury [7015002]"] 
-    n.title.should ==  ["Oral history with Frances Addelson, 1997 November 14"]
-  end
-
-
   it "should default dc elements to :multiple=>true" do
     @test_ds.fields.values.each do |s|
       s.has_key?(:multiple).should == true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2012-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr
@@ -132,7 +132,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -140,7 +140,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
@@ -547,7 +547,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1381095155313457398
+      hash: 1953384027412583445
 requirements: []
 rubyforge_project: rubyfedora
 rubygems_version: 1.8.23