active-fedora 6.4.0.rc1 → 6.4.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a57c2dc577a4f6595cba76b441203b6d6663d083
-  data.tar.gz: d8192c0c8615c94caf0ebe10820866981eb870e9
+  metadata.gz: 9f6463fca15144a94e10e6c80c86871f57867c2b
+  data.tar.gz: d08ad6e9492d3d62fa5227ce779539ffd83406bc
 SHA512:
-  metadata.gz: b6e1153143dc1a2140c155fbffdfa17e721a05c187cdc54f97099a17dd4ff7db3c738eb2de016128b9f3aec119282bf91804f3d2baaa8a3ae95dcc4d54fd4a0b
-  data.tar.gz: 4492eb4d126ee07a15c43e9403722fa5dca9d26d111d8aa6fe680c78d7602bf48cacbf1fa93b4cb66fc551fbce1a61d59c89dbab0632ef365626b24fb4bf1ecf
+  metadata.gz: 13a56b47d6da5d2c173f67f255a30e5d7bdf1b4e6c1a98cd3cff69390bbe5a463ef3b4e2167976f7ef1c55defa7844224ba6cfa769e38ad057bb49e0fb12c53f
+  data.tar.gz: 64befaef8bdcbb7f54443591ceba0d71d98ceacf5fc303b0e162bf6cdbd38bb8f2709ea52e5e5e19e492591127cb810c09bdb1fb61d90ab0b5bce6624ec7328d

data/lib/active_fedora/rdf/nested_attributes.rb

@@ -25,19 +25,60 @@ module ActiveFedora
         association = self.send(association_name)
 
         attributes_collection.each do |attributes|
-          if attributes.instance_of? Hash
+          attributes = attributes.with_indifferent_access
+          
+          if attributes['id'].blank?
             attributes = attributes.with_indifferent_access
             association.build(attributes.except(*UNASSIGNABLE_KEYS))
+          elsif existing_record = association.detect { |record| record.rdf_subject.to_s == attributes['id'].to_s }
+            if !call_reject_if(association_name, attributes)
+              assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+            end
           else
-            association.build(attributes)            
+            raise_nested_attributes_record_not_found(association_name, record.rdf_subject.to_s)
           end
         end
       end
 
+      # Updates a record with the +attributes+ or marks it for destruction if
+      # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
+      def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
+        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+        record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
+      end
+
+      def raise_nested_attributes_record_not_found(association_name, record_id)
+        raise RecordNotFound, "Couldn't find #{association_name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+      end
+
+      def call_reject_if(association_name, attributes)
+        return false if has_destroy_flag?(attributes)
+        case callback = self.nested_attributes_options[association_name][:reject_if]
+        when Symbol
+          method(callback).arity == 0 ? send(callback) : send(callback, attributes)
+        when Proc
+          callback.call(attributes)
+        end
+      end
+
+      # Determines if a hash contains a truthy _destroy key.
+      def has_destroy_flag?(hash)
+        ["1", "true"].include?(hash['_destroy'].to_s)
+      end
+      
+
       module ClassMethods
-        def accepts_nested_attributes_for *relationships
-          relationships.each do |association_name|
-            nested_attributes_options[association_name] = {}
+        def accepts_nested_attributes_for *attr_names
+          options = { :allow_destroy => false, :update_only => false }
+          options.update(attr_names.extract_options!)
+          options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
+          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+
+          attr_names.each do |association_name|
+            nested_attributes_options = self.nested_attributes_options.dup
+            nested_attributes_options[association_name] = options
+            self.nested_attributes_options = nested_attributes_options
+
             generate_association_writer(association_name)
           end
         end
@@ -56,16 +97,17 @@ module ActiveFedora
         # the helper methods defined below. Makes it seem like the nested
         # associations are just regular associations.
         def generate_association_writer(association_name)
-            class_eval <<-eoruby, __FILE__, __LINE__ + 1
-              if method_defined?(:#{association_name}_attributes=)
-                remove_method(:#{association_name}_attributes=)
-              end
-              def #{association_name}_attributes=(attributes)
-                unless attributes.nil?
-                  assign_nested_attributes_for_collection_association(:#{association_name}, attributes)
-                end
-              end
-            eoruby
+          class_eval <<-eoruby, __FILE__, __LINE__ + 1
+            if method_defined?(:#{association_name}_attributes=)
+              remove_method(:#{association_name}_attributes=)
+            end
+            def #{association_name}_attributes=(attributes)
+              assign_nested_attributes_for_collection_association(:#{association_name}, attributes)
+              ## in lieu of autosave_association_callbacks just save all of em.
+              send(:#{association_name}).each {|obj| obj.marked_for_destruction? ? obj.destroy : nil}
+              send(:#{association_name}).reset!
+            end
+          eoruby
         end
       end
     end

data/lib/active_fedora/rdf_datastream.rb

@@ -42,6 +42,7 @@ module ActiveFedora
     end
 
     def content=(content)
+      reset_child_cache!
       @graph = deserialize(content)
     end
 
@@ -98,6 +99,7 @@ module ActiveFedora
     # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
     def serialize
       update_subjects_to_use_a_real_pid!
+
       RDF::Writer.for(serialization_format).dump(graph)
     end
 
@@ -109,6 +111,7 @@ module ActiveFedora
 
       bad_subject = rdf_subject
       reset_rdf_subject!
+      reset_child_cache!
       new_subject = rdf_subject
 
       new_repository = RDF::Repository.new
@@ -125,7 +128,7 @@ module ActiveFedora
 
     # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
     def fields
-      field_map = {}
+      field_map = {}.with_indifferent_access
 
       rdf_subject = self.rdf_subject
       query = RDF::Query.new do

data/lib/active_fedora/rdf_list.rb

@@ -9,6 +9,10 @@ module ActiveFedora
       graph.insert([subject, RDF.rest, RDF.nil])
     end
 
+    def rdf_subject
+      subject
+    end
+
     def first
       self[0] 
     end

data/lib/active_fedora/rdf_node.rb

@@ -36,12 +36,17 @@ module ActiveFedora
       @subject = nil
     end
 
+    def reset_child_cache!
+      @target = {}
+    end
+
     # @param [RDF::URI] subject the base node to start the search from
     # @param [Symbol] term the term to get the values for
     def get_values(subject, term)
       options = config_for_term_or_uri(term)
       predicate = options[:predicate]
-      TermProxy.new(self, subject, predicate, options)
+      @target ||= {}
+      @target[term.to_s] ||= TermProxy.new(self, subject, predicate, options)
     end
 
     def target_class(predicate)
@@ -51,12 +56,20 @@ module ActiveFedora
       ActiveFedora.class_from_string(class_name, self.class)
     end
 
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+
     # if there are any existing statements with this predicate, replace them
     # @param [RDF::URI] subject  the subject to insert into the graph
     # @param [Symbol, RDF::URI] predicate  the predicate to insert into the graph
     # @param [Array,#to_s] values  the value/values to insert into the graph
-    def set_value(subject, predicate, values)
-      options = config_for_term_or_uri(predicate)
+    def set_value(subject, term, values)
+      options = config_for_term_or_uri(term)
       predicate = options[:predicate]
       values = Array(values)
 
@@ -71,20 +84,46 @@ module ActiveFedora
         end
       end
 
-      TermProxy.new(self, subject, predicate, options)
+      @target ||= {}
+      proxy = @target[term.to_s]
+      proxy ||= TermProxy.new(self, subject, predicate, options)
+      proxy.reset!
+      proxy
+
+    end
+
+    # Be careful with destroy. It will still be in the cache untill you call reset()
+    def destroy
+      # delete any statements about this rdf_subject
+      subject = rdf_subject
+      query = RDF::Query.new do
+        pattern [subject, :predicate, :value]
+      end
+
+      query.execute(graph).each do |solution|
+        graph.delete [subject, solution.predicate, solution.value]
+      end
+
+      # delete any statements that reference this rdf_subject
+      query = RDF::Query.new do
+        pattern [:subject, :predicate, subject]
+      end
+
+      query.execute(graph).each do |solution|
+        graph.delete [solution.subject, solution.predicate, subject]
+      end
     end
 
     # @option [Hash] values the values to assign to this rdf node.
     def attributes=(values)
       raise ArgumentError, "values must be a Hash, you provided #{values.class}" unless values.kind_of? Hash
-      self.class.config.keys.each do |key|
-        if values.has_key?(key)
-          set_value(rdf_subject, key, values[key])
+      values.with_indifferent_access.each do |key, value|
+        if self.class.config.keys.include?(key)
+          set_value(rdf_subject, key, value)
+        elsif nested_attributes_options.keys.map{ |k| "#{k}_attributes"}.include?(key)
+          send("#{key}=".to_sym, value)
         end
       end
-      nested_attributes_options.keys.each do |key|
-        send("#{key}_attributes=".to_sym, values["#{key}_attributes".to_sym])
-      end
     end
  
     def delete_predicate(subject, predicate, values = nil)
@@ -103,6 +142,7 @@ module ActiveFedora
           graph.delete [subject, predicate, v]
         end
       end
+      reset_child_cache!
     end
 
     # append a value 
@@ -110,7 +150,6 @@ module ActiveFedora
     def append(subject, predicate, args)
       options = config_for_term_or_uri(predicate)
       graph.insert([subject, predicate, args])
-      TermProxy.new(self, subject, options[:predicate], options)
     end
 
     def config_for_term_or_uri(term)
@@ -139,8 +178,8 @@ module ActiveFedora
     end
 
     def method_missing(name, *args)
-      if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
-          set_value(rdf_subject, pred, *args)  
+      if md = /^([^=]+)=$/.match(name.to_s)
+          set_value(rdf_subject, md[1], *args)  
       elsif find_predicate(name)
           get_values(rdf_subject, name)
       else 
@@ -244,7 +283,7 @@ module ActiveFedora
 
     module ClassMethods
       def config
-        @config ||= {}
+        @config ||= {}.with_indifferent_access
       end
 
       def map_predicates(&block)

data/lib/active_fedora/rdf_node/term_proxy.rb

@@ -2,45 +2,57 @@ module ActiveFedora
   module RdfNode
     class TermProxy
 
-      attr_reader :graph, :subject, :predicate, :options
-
-      delegate *(Array.public_instance_methods - [:__send__, :__id__, :class, :object_id] + [:as_json]), :to => :values
+      attr_reader :parent, :subject, :predicate, :options
+      delegate *(Array.public_instance_methods - [:__send__, :__id__, :class, :object_id] + [:as_json]), :to => :target
+      
 
-      # @param graph RDF::Graph
+      # @param parent RdfNode
       # @param subject RDF::URI
       # @param options Hash
-      def initialize(graph, subject, predicate, options)
-        @graph = graph
+      def initialize(parent, subject, predicate, options)
+        @parent = parent
         @subject = subject
         @predicate = predicate
         @options = options
       end
 
+
       def build(attributes=nil)
         new_subject = RDF::Node.new
-        graph.graph.insert([subject, predicate, new_subject])
-        graph.target_class(predicate).new(graph.graph, new_subject).tap do |node|
+        parent.graph.insert([subject, predicate, new_subject])
+        parent.target_class(predicate).new(parent.graph, new_subject).tap do |node|
           node.attributes = attributes if attributes
         end
+        reset!
+        target.find { |n| n.rdf_subject == new_subject}
+      end
+
+      def reset!
+        @target = nil
       end
 
       def <<(*values)
-        values.each { |value| graph.append(subject, predicate, value) }
+        values.each { |value| parent.append(subject, predicate, value) }
+        reset!
         values
       end
 
       def delete(*values)
         values.each do |value| 
-          graph.delete_predicate(subject, predicate, value)
+          parent.delete_predicate(subject, predicate, value)
         end
 
         values
       end
 
-      def values
+      def target
+        @target ||= load_values
+      end
+
+      def load_values
         values = []
 
-        graph.query(subject, predicate).each do |solution|
+        parent.query(subject, predicate).each do |solution|
           v = solution.value
           v = v.to_s if v.is_a? RDF::Literal
           if options[:type] == :date
@@ -50,14 +62,14 @@ module ActiveFedora
           # potential solution is of the right RDF.type
           if options[:class_name]
             klass =  class_from_rdf_type(v)
-            values << v if klass == ActiveFedora.class_from_string(options[:class_name], graph.class)
+            values << v if klass == ActiveFedora.class_from_string(options[:class_name], parent.class)
           else
             values << v
           end
         end
 
         if options[:class_name]
-          values = values.map{ |found_subject| class_from_rdf_type(found_subject).new(graph.graph, found_subject)}
+          values = values.map{ |found_subject| class_from_rdf_type(found_subject).new(parent.graph, found_subject)}
         end
         
         values
@@ -66,7 +78,7 @@ module ActiveFedora
       private 
 
       def target_class
-        graph.target_class(predicate)
+        parent.target_class(predicate)
       end
 
       # Look for a RDF.type assertion on this node to see if an RDF class is specified.
@@ -78,7 +90,7 @@ module ActiveFedora
         end
 
         type_uri = []
-        q.execute(graph.graph).each do |sol| 
+        q.execute(parent.graph).each do |sol| 
           type_uri << sol.value
         end
         

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "6.4.0.rc1"
+  VERSION = "6.4.0.rc2"
 end

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -35,6 +35,23 @@ describe "Nested Rdf Objects" do
       ds.parts.first.label.should == ["Alternator"]
     end
 
+    it "should be able to replace attributes" do
+      v = ds.parts.build(label: 'Alternator')
+      ds.parts.first.label.should == ['Alternator']
+      ds.parts.first.label = ['Distributor']
+      ds.parts.first.label.should == ['Distributor']
+    end
+
+    it "should be able to replace objects" do
+      ds.parts.build(label: 'Alternator')
+      ds.parts.build(label: 'Distributor')
+      ds.parts.size.should == 2
+      comp = SpecDatastream::Component.new(ds.graph)
+      comp.label = "Injector port"
+      ds.parts = [comp]
+      ds.parts.size.should == 1
+    end
+
     it "should be able to nest many complex objects" do
       comp1 = SpecDatastream::Component.new ds.graph
       comp1.label = ["Alternator"]

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -1,118 +1,157 @@
 require 'spec_helper'
 
-describe ActiveFedora::RDFDatastream do
-    before do 
-      class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
-        # componentList and Types of components
-        property :componentList
-        property :Topic
-        property :Temporal
-        property :PersonalName
-        property :CorporateName
-        property :ComplexSubject
-        
-        
-        # elementList and elementList values
-        property :elementList
-        property :elementValue
-        property :TopicElement
-        property :TemporalElement
-        property :NameElement
-        property :FullNameElement
-        property :DateNameElement
-      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)
+describe "Nesting attribute behavior of RDFDatastream" do
+  describe ".attributes=" do
+    describe "complex properties" do
+      before do 
+        class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+          # componentList and Types of components
+          property :componentList
+          property :Topic
+          property :Temporal
+          property :PersonalName
+          property :CorporateName
+          property :ComplexSubject
+          
+          
+          # elementList and elementList values
+          property :elementList
+          property :elementValue
+          property :TopicElement
+          property :TemporalElement
+          property :NameElement
+          property :FullNameElement
+          property :DateNameElement
         end
 
-        accepts_nested_attributes_for :topic, :personalName
-
-        class Topic
-          include ActiveFedora::RdfObject
+        class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.elementList(in: DummyMADS, class_name:"ComplexRDFDatastream::ElementList")
+            map.topic(in: DummyMADS, to: "Topic", class_name:"Topic")
+            map.personalName(in: DummyMADS, to: "PersonalName", class_name:"PersonalName")
+            map.title(in: RDF::DC)
           end
-          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")
+
+          accepts_nested_attributes_for :topic, :personalName
+
+          class Topic
+            include ActiveFedora::RdfObject
+            map_predicates do |map|
+              map.elementList(in: DummyMADS, class_name:"ComplexRDFDatastream::ElementList")
+            end
+            accepts_nested_attributes_for :elementList
           end
-          accepts_nested_attributes_for :elementList, :extraProperty
-        end
-        class ElementList
-          include ActiveFedora::RdfObject
-          rdf_type DummyMADS.elementList
-          map_predicates do |map|
-            map.topicElement(in: DummyMADS, to: "TopicElement")
-            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)
+          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
+            accepts_nested_attributes_for :elementList, :extraProperty
+          end
+          class ElementList
+            include ActiveFedora::RdfObject
+            rdf_type DummyMADS.elementList
+            map_predicates do |map|
+              map.topicElement(in: DummyMADS, to: "TopicElement")
+              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
           end
         end
       end
-    end
-    after do
-      Object.send(:remove_const, :ComplexRDFDatastream)
-      Object.send(:remove_const, :DummyMADS)
-    end
-    subject { ComplexRDFDatastream.new(stub('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
-    
-    describe ".attributes=" do
-      describe "complex properties" do
-        let(:params) do 
-          { myResource: 
-            {
-              topic_attributes: [
-                {
-                  elementList_attributes: {
-                    topicElement:"Cosmology"
-                    }
-                },
-                {
-                  elementList_attributes: {
-                    topicElement:"Quantum Behavior"
-                  }
-                }
-              ],
-              personalName_attributes: [
-                { 
-                  elementList_attributes: {
-                    fullNameElement: "Jefferson, Thomas",
-                    dateNameElement: "1743-1826"                  
-                  }
-                } 
-                #, "Hemings, Sally"
-              ],
-            }
+      after do
+        Object.send(:remove_const, :ComplexRDFDatastream)
+        Object.send(:remove_const, :DummyMADS)
+      end
+      subject { ComplexRDFDatastream.new(stub('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
+      let(:params) do 
+        { myResource: 
+          {
+            topic_attributes: [
+              {
+                elementList_attributes: [{
+                  topicElement:"Cosmology"
+                  }]
+              },
+              {
+                elementList_attributes: [{
+                  topicElement:"Quantum Behavior"
+                }]
+              }
+            ],
+            personalName_attributes: [
+              { 
+                elementList_attributes: [{
+                  fullNameElement: "Jefferson, Thomas",
+                  dateNameElement: "1743-1826"                  
+                }]
+              } 
+              #, "Hemings, Sally"
+            ],
           }
-        end
-        it "should support mass-assignment" do
-            # Replace the graph's contents with the Hash
-            subject.attributes = params[:myResource]
+        }
+      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'
+          # 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.first.elementList.first.topicElement.should == ["Cosmology"]
-            subject.topic[1].elementList.first.topicElement.should == ["Quantum Behavior"]
-            subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
-            subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
-        end
-      end    
+          subject.topic.first.elementList.first.topicElement.should == ["Cosmology"]
+          subject.topic[1].elementList.first.topicElement.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 
+        class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
+          map_predicates do |map|
+            map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
+          end
+          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
+          end
+        end
+
+      end
+      
+      after(:each) do
+        Object.send(:remove_const, :SpecDatastream)
+      end
+      subject { SpecDatastream.new(stub('inner object', :pid=>'foo', :new? =>true), 'descMetadata') }
+      before do
+        subject.attributes = { parts_attributes: [
+                                  {label: 'Alternator'},
+                                  {label: 'Distributor'},
+                                  {label: 'Transmission'},
+                                  {label: 'Fuel Filter'}]}
+      end
+      let (:replace_object_id) { subject.parts[1].rdf_subject.to_s }
+      let (:remove_object_id) { subject.parts[3].rdf_subject.to_s }
+
+      it "should update nested objects" do
+        subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
+
+        subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
+
+      end
+    end    
+  end
 end

data/spec/unit/ntriples_datastream_spec.rb

@@ -223,7 +223,7 @@ describe ActiveFedora::NtriplesRDFDatastream do
 
       describe ".fields()" do
         it "should return the right fields" do
-          @obj.send(:fields).keys.should == [:created, :title, :publisher, :based_near, :related_url]
+          @obj.send(:fields).keys.should == ["created", "title", "publisher", "based_near", "related_url"]
         end
         it "should return the right values" do
           fields = @obj.send(:fields)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 6.4.0.rc1
+  version: 6.4.0.rc2
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr