active-fedora 6.4.4 → 6.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9682552f64d1274de9b4de8f26e12dc1ab04cab5
-  data.tar.gz: 0267bbbfcd15b12ab6593620aebab8e2e6322274
+  metadata.gz: 5c3b9301740101d4e6c50bd6d5ce3f8e6bdf5d48
+  data.tar.gz: 84fed4e80fc0a7d1f5d2123836867f804427f797
 SHA512:
-  metadata.gz: 8fdd12fb3660f58afca86fa8f488d3da34db1e36ceb55b76d3cda5f33f6a87a2b668bbcc6841d07a7d62f14d32fb77e61811fad3a29cd1a268175b30dd536587
-  data.tar.gz: 96459b1261137d65d9f64e2dab39587aac41466f958b943da81a19799ec7d7f6a343b353332984d43de296d161172861fdea152854811056f04d2d1a64b60e85
+  metadata.gz: 70b1bcb60f130c770e54866396de53f876d3529b0befce9bcfc180fe6b2540630c7b4df492057fe7dd4e2406b3cd35ecb9cd1a675af3f3ff0591be4716d752ba
+  data.tar.gz: d66329975f4374c0a46102235195760b1ac72ef7bddba684f9bbe6af16d2b2fc65cec3f7c526bed7870b0b38cb4a38569d480fce812b35b02e146306e5ec1543

data/History.txt

@@ -1,3 +1,132 @@
+v6.4.5 (2013-08-05)
+
+Clear rdf lists and proxies [Justin Coyne]
+
+When defining rdf terminologies you should be able to say 'multivalue: false'
+[Justin Coyne]
+
+Created RdfList#to_ary [Justin Coyne]
+
+Define UNASSIGNABLE_KEYS for RdfList.assign_nested_attributes... [Justin Coyne]
+
+Added RdfList.each [Justin Coyne]
+
+Cache the tail node in an RDFList [Justin Coyne]
+
+class_from_string should have an exit condition when the class can't be found
+[Justin Coyne]
+
+Add a warning letting you know you may have already registered this RDF.type
+[Justin Coyne]
+
+Rdf lists should only have one RDF.rest node [Justin Coyne]
+
+RDF lists should be able to accept nested attributes as a hash [Justin Coyne]
+
+Clean up YARD doc warnings [Justin Coyne]
+
+An rdf node should be able to set rdf:about [Justin Coyne]
+
+Remove RdfObject#get_values, it's inherited [Justin Coyne]
+
+
+v6.4.4 (2013-07-29)
+
+Bumping to version 6.4.4 [Jeremy Friesen]
+
+Use get_config_path to get the path for the predicate_mappings.yml
+[Justin Coyne]
+
+has_and_belongs_to_many can have more than 10 results. [Justin
+Coyne]
+
+Filters belongs_to associations by :class_name if specified [Simon
+Lamb]
+
+Don't reindex fedora-system objects in reindex_everything [Justin
+Coyne]
+
+Adding "An ActiveModel" shared behavior [Jeremy Friesen]
+
+Allow query parameter AF.reindex_everything [Jeremy Friesen]
+
+Updating CONTRIBUTING.md as per Hydra v6.0.0 [Jeremy Friesen]
+
+The example test should look for Base.exists?() rather than checking
+to see that an ObjectNotFound error is raised. [Justin Coyne]
+
+
+v6.4.3 (2013-07-16)
+
+class_from_string should find sibiling classes [Justin Coyne]
+
+Ensuring that AF::Base.find("") raises exception [Jeremy Friesen]
+
+Added ActiveFedora::SolrService.lazy_reify_solr_results to provide
+lazy (Ruby 1.9-compatible) reification alternative to .reify_solr_results.
+ActiveFedora::SolrService.reify_solr_results refactored, extracting single
+reification to .reify_solr_result. Supplied missing test for :load_from_solr
+option to .reify_solr_results [David Chandek-Stark]
+
+Adding mailmap for improving changelog generation [Jeremy Friesen]
+
+Tidying up how ActiveFedora::Base.exists? behaves [Jeremy Friesen]
+
+Tidying up hash key access of AF::Model [Jeremy Friesen]
+
+Fixed test for equality within OmDatastream.changed? [Justin Coyne]
+
+mock() and stub() are deprecated. Switched to double() [Justin
+Coyne]
+
+Remove all serialized foxml in favor of programmatic creation of
+fixtures in preperation for Fedora 4; One broken test revealed dealing with
+managed om datastreams [Chris Colvard]
+
+
+v6.4.2 (2013-07-10)
+
+Bumping version to 6.4.2 [Jeremy Friesen]
+
+In activerecord 4.0 the update() method accepts arguments. Conform
+to that interface. [Justin Coyne]
+
+
+v6.4.1 (2013-07-10)
+
+Change generator template to not use named argument 'name' [Justin
+Coyne]
+
+Infer the property on has_many. Fixes #142 [Justin Coyne]
+
+Added new_record? method to Rdf nodes [Justin Coyne]
+
+Test the behavior when the node can't be found [Justin Coyne]
+
+Rdf nested attributes should accept hashes [Justin Coyne]
+
+Added :type to ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.
+Presumably this field was excluded due to Object#type from Ruby 1.8. Since AF
+currently requires >= Ruby 1.9.3, it appears safe to add this DC 1.1 element.
+[David Chandek-Stark]
+
+Removed outdated comment that OmDatastream is just an alias for
+NokogiriDatastream [David Chandek-Stark]
+
+Added :path option to
+ActiveFedora::QualifiedDublinCoreDatastream#field in order to support, for
+example, mapping the term :dc_type to <dcterms:type> (:type is excluded from
+ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS). Implementation simply
+adds :path (even if nil) to OM::XML::Term.new since initializer falls back to
+field name anyway. [David Chandek-Stark]
+
+Generate a datastream in addition to the model [Justin Coyne]
+
+Autoload classes in app/models/datastreams [Justin Coyne]
+
+Remove unnecessary require of 'active_fedora/base' in model template [Justin Coyne]
+
+
 6.4.0 (2013-07-01)
 
 Removing experimental designation, tidying-up the code [Adam Wead]

data/lib/active_fedora.rb

@@ -22,7 +22,6 @@ module ActiveFedora #:nodoc:
   class AssociationTypeMismatch < RuntimeError; end # :nodoc:
   class UnregisteredPredicateError < RuntimeError; end # :nodoc:
   class RecordNotSaved < RuntimeError; end # :nodoc:
-  class RecordNotFound < RuntimeError; end # :nodoc:
 
 
   eager_autoload do
@@ -161,7 +160,9 @@ module ActiveFedora #:nodoc:
     container_class = container_class.name if container_class.is_a? Module
     container_parts = container_class.split('::')
     (container_parts + class_name.split('::')).flatten.inject(Kernel) do |mod, class_name|
-      if mod.const_defined? class_name.to_sym
+      if mod == Kernel
+        Object.const_get(class_name)
+      elsif mod.const_defined? class_name.to_sym
         mod.const_get(class_name)
       else
         container_parts.pop

data/lib/active_fedora/delegating.rb

@@ -103,8 +103,8 @@ module ActiveFedora
       end
 
       # Reveal if the delegated field is unique or not
-      # @params [Symbol] field the field to query
-      # @returns [Boolean]
+      # @param [Symbol] field the field to query
+      # @return [Boolean]
       def unique?(field)
         delegates[field][:unique]
       end

data/lib/active_fedora/indexing.rb

@@ -87,7 +87,7 @@ module ActiveFedora
       end
 
       # Using the fedora search (not solr), get every object and reindex it.
-      # @param [String] a query string that conforms to the query param format
+      # @param [String] query a string that conforms to the query param format
       #   of the underlying search's API
       def reindex_everything(query = nil)
         connections.each do |conn|

data/lib/active_fedora/rdf.rb

@@ -2,5 +2,6 @@ module ActiveFedora
   module Rdf
     extend ActiveSupport::Autoload
     autoload :NestedAttributes
+    autoload :NodeConfig
   end
 end

data/lib/active_fedora/rdf/nested_attributes.rb

@@ -10,10 +10,10 @@ module ActiveFedora
 
       private
 
-      UNASSIGNABLE_KEYS = %w( id _destroy )
+      UNASSIGNABLE_KEYS = %w(_destroy )
 
-      # @params [Symbol] association_name
-      # @params [Hash, Array] attributes_collection
+      # @param [Symbol] association_name
+      # @param [Hash, Array] attributes_collection
       # @example
       #
       #   assign_nested_attributes_for_collection_association(:people, {
@@ -39,7 +39,7 @@ module ActiveFedora
         # TODO
         #check_record_limit!(options[:limit], attributes_collection)
 
-        if attributes_collection.is_a?(Hash)# || attributes_collection.is_a?(String)
+        if attributes_collection.is_a?(Hash)
           attributes_collection = attributes_collection.values
         end
 
@@ -48,15 +48,13 @@ module ActiveFedora
         attributes_collection.each do |attributes|
           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 attributes['id'] && 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
-            raise_nested_attributes_record_not_found(association_name, attributes['id'].to_s)
+            attributes = attributes.with_indifferent_access
+            association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
         end
       end
@@ -68,10 +66,6 @@ module ActiveFedora
         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=#{rdf_subject.to_s}"
-      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]

data/lib/active_fedora/rdf/node_config.rb

@@ -0,0 +1,41 @@
+module ActiveFedora
+  module Rdf
+    class NodeConfig
+      attr_accessor :predicate, :class_name, :type, :behaviors, :multivalue
+
+      def initialize(predicate, args={})
+        self.predicate = predicate
+        self.class_name = args.delete(:class_name)
+        self.multivalue = args.delete(:multivalue) { true } 
+        raise ArgumentError, "Invalid arguments for Rdf Node configuration: #{args} on #{predicate}" unless args.empty?
+      end
+
+
+      def with_index (&block)
+        # needed for solrizer integration
+        iobj = IndexObject.new
+        yield iobj
+        self.type = iobj.data_type
+        self.behaviors = iobj.behaviors
+      end
+
+      # this enables a cleaner API for solr integration
+      class IndexObject
+        attr_accessor :data_type, :behaviors
+        def initialize
+          @behaviors = []
+          @data_type = :string
+        end
+        def as(*args)
+          @behaviors = args
+        end
+        def type(sym)
+          @data_type = sym
+        end
+        def defaults
+          :noop
+        end
+      end
+    end
+  end
+end

data/lib/active_fedora/rdf_datastream.rb

@@ -141,8 +141,8 @@ module ActiveFedora
         
         name, config = self.class.config_for_predicate(predicate)
         next unless config
-        type = config[:type]
-        behaviors = config[:behaviors]
+        type = config.type
+        behaviors = config.behaviors
         next unless type and behaviors 
         field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
         field_map[name][:values] << value.to_s

data/lib/active_fedora/rdf_list.rb

@@ -5,14 +5,22 @@ module ActiveFedora
     
     attr_reader :graph, :subject
     
+    # RdfList is a node of a linked list structure.
+    # The RDF.first predicate points to the contained object
+    # The RDF.rest predicate points to the next node in the list or 
+    #   RDF.nil if this is the final node.
+    # @see http://www.w3.org/TR/rdf-schema/#ch_list
     def initialize(graph, subject)
       @graph = graph
       @subject = subject
       first = graph.query([subject, RDF.first, nil]).first
+      last = graph.query([subject, RDF.rest, nil]).first
       graph.insert([subject, RDF.first, RDF.nil]) unless first
-      graph.insert([subject, RDF.rest, RDF.nil])
+      graph.insert([subject, RDF.rest, RDF.nil]) unless last
     end
-    
+
+    UNASSIGNABLE_KEYS = %w(_destroy )
+
     # Override assign_nested_attributes
     def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
       options = self.nested_attributes_options[association_name]
@@ -20,24 +28,26 @@ module ActiveFedora
       # TODO
       #check_record_limit!(options[:limit], attributes_collection)
     
-      if attributes_collection.is_a?(Hash) || attributes_collection.is_a?(String)
-        attributes_collection = [attributes_collection]
+      if attributes_collection.is_a?(Hash)
+        attributes_collection = attributes_collection.values
       end
     
       association = self.send(association_name)
       
       original_length_of_list = self.size
       attributes_collection.each_with_index do |attributes, index|
-        if attributes.instance_of? Hash
-          attributes = attributes.with_indifferent_access
-          minted_node = association.mint_node(attributes.except(*UNASSIGNABLE_KEYS))
-        else
-          minted_node = association.mint_node(attributes)            
-        end
+        attributes = attributes.with_indifferent_access
+        minted_node = association.mint_node(attributes.except(*UNASSIGNABLE_KEYS))
         self[original_length_of_list+index] = minted_node
       end
     end
 
+
+    # Override the method from RdfNode, enabling us to insert into the list.
+    def insert_child(predicate, node)
+      self[size] = node
+    end
+
     def rdf_subject
       subject
     end
@@ -54,11 +64,48 @@ module ActiveFedora
       idx == 0 ?  head.value=value : tail_or_create(idx-1).value=value
     end
 
+    def clear(first_element=true)
+      # Remove the pointed at element
+      v = graph.query([subject, RDF.first, nil]).first
+      # TODO - Recursive delete
+      graph.delete([v.object, nil, nil])
+      
+      # Remove the tail
+      tail.clear(false) if tail
+      # clear the cache
+      @tail = nil
+      graph.delete([subject, nil, nil])
+      if first_element
+        # Re-add first/rest predicates if its the first node
+        graph.insert([subject, RDF.first, RDF.nil])
+        graph.insert([subject, RDF.rest, RDF.nil])
+      end
+    end
+
+    def each &block
+      yield(head.value)
+      tail.each(&block) if tail
+    end
+
+    def to_ary
+      if empty?
+        []
+      elsif tail
+        [head.value] + tail.to_ary
+      else
+        [head.value]
+      end
+    end
+
+    def empty?
+      !tail && graph.query([subject, RDF.first, RDF.nil]).first
+    end 
+
     def size
-      if tail
-        tail.size + 1
-      elsif graph.query([subject, RDF.first, RDF.nil]).first
+      if empty?
         0
+      elsif tail
+        tail.size + 1
       else
         1
       end
@@ -70,7 +117,9 @@ module ActiveFedora
 
     def value
       v = graph.query([subject, RDF.first, nil]).first
-      return v.object if v.object.uri?
+      if v.object.uri?
+        return v.object == RDF.nil ? nil : v.object
+      end
       if v.object.resource?
         type = graph.query([v.object, RDF.type, nil]).first
         return ActiveFedora::RdfNode.rdf_registry[type.object].new(graph, v.object)
@@ -92,24 +141,22 @@ module ActiveFedora
     end
 
     def tail
+      return @tail if @tail
       rest = graph.query([subject, RDF.rest, nil]).first
       return if rest.object == RDF.nil
-      self.class.new(graph, rest.object)
+      @tail = self.class.new(graph, rest.object)
     end
 
     def tail_or_create(idx)
-      rest = graph.query([subject, RDF.rest, nil]).first
-      obj = if rest.object != RDF.nil 
-        self.class.new(graph, rest.object)
-      else
+      unless tail
         #add a tail
         graph.delete([subject, RDF.rest, RDF.nil])
-        tail = RDF::Node.new
-        graph.insert([subject, RDF.rest, tail])
-        self.class.new(graph, tail)
+        tail_node = RDF::Node.new
+        graph.insert([subject, RDF.rest, tail_node])
+        @tail = self.class.new(graph, tail_node)
       end
 
-      idx == 0 ? obj : obj.tail_or_create(idx-1)
+      idx == 0 ? @tail : @tail.tail_or_create(idx-1)
     end
   end
 end

data/lib/active_fedora/rdf_node.rb

@@ -44,14 +44,14 @@ module ActiveFedora
     # @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]
+      predicate = options.predicate
       @target ||= {}
       @target[term.to_s] ||= TermProxy.new(self, subject, predicate, options)
     end
 
     def target_class(predicate)
       _, conf = self.class.config_for_predicate(predicate)
-      class_name = conf[:class_name]
+      class_name = conf.class_name
       return nil unless class_name
       ActiveFedora.class_from_string(class_name, self.class)
     end
@@ -74,11 +74,11 @@ module ActiveFedora
 
     # 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 [Symbol, RDF::URI] term the term to insert into the graph
     # @param [Array,#to_s] values  the value/values to insert into the graph
     def set_value(subject, term, values)
       options = config_for_term_or_uri(term)
-      predicate = options[:predicate]
+      predicate = options.predicate
       values = Array(values)
 
       remove_existing_values(subject, predicate, values)
@@ -160,10 +160,15 @@ module ActiveFedora
       graph.insert([subject, predicate, args])
     end
 
+    def insert_child(predicate, node)
+      graph.insert([rdf_subject, predicate, node.rdf_subject])
+    end
+
+
     def config_for_term_or_uri(term)
       case term
       when RDF::URI
-        self.class.config.each { |k, v| return v if v[:predicate] == term}
+        self.class.config.each { |k, v| return v if v.predicate == term}
       else
         self.class.config[term.to_sym]
       end
@@ -172,7 +177,7 @@ module ActiveFedora
     # @param [Symbol, RDF::URI] term predicate  the predicate to insert into the graph
     def find_predicate(term)
       conf = config_for_term_or_uri(term)
-      conf ? conf[:predicate] : nil
+      conf ? conf.predicate : nil
     end
 
     def query subject, predicate, &block
@@ -248,45 +253,14 @@ module ActiveFedora
       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]
-        field = args.fetch(:to, name).to_sym
-        class_name = args[:class_name]
+        vocab = args.delete(:in)
+        field = args.delete(:to) {name}.to_sym
         raise "Vocabulary '#{vocab.inspect}' does not define property '#{field.inspect}'" unless vocab.respond_to? field
-        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
-        @parent.config[name] = {:predicate => vocab.send(field) } 
-        # stuff data_type and behaviors in there for to_solr support
-        if indexing
-          @parent.config[name][:type] = data_type
-          @parent.config[name][:behaviors] = behaviors
+        @parent.config[name] = Rdf::NodeConfig.new(vocab.send(field), args).tap do |config|
+          config.with_index(&block) if block_given?
         end
-        @parent.config[name][:class_name] = class_name if class_name
       end
 
-      # this enables a cleaner API for solr integration
-      class IndexObject
-        attr_accessor :data_type, :behaviors
-        def initialize
-          @behaviors = []
-          @data_type = :string
-        end
-        def as(*args)
-          @behaviors = args
-        end
-        def type(sym)
-          @data_type = sym
-        end
-        def defaults
-          :noop
-        end
-      end
     end
 
     module ClassMethods
@@ -315,8 +289,9 @@ module ActiveFedora
       def rdf_type(uri_or_string=nil)
         if uri_or_string
           uri = uri_or_string.kind_of?(RDF::URI) ? uri_or_string : RDF::URI.new(uri_or_string) 
-          self.config[:type] = {predicate: RDF.type}
+          self.config[:type] = Rdf::NodeConfig.new(RDF.type)
           @rdf_type = uri
+          logger.warn "Duplicate RDF Class. Trying to register #{self} for #{uri} but it is already registered for #{ActiveFedora::RdfNode.rdf_registry[uri]}" if ActiveFedora::RdfNode.rdf_registry.key? uri
           ActiveFedora::RdfNode.rdf_registry[uri] = self
         end
         @rdf_type
@@ -324,7 +299,7 @@ module ActiveFedora
 
       def config_for_predicate(predicate)
         config.each do |term, value|
-          return term, value if value[:predicate] == predicate
+          return term, value if value.predicate == predicate
         end
         return nil
       end

data/lib/active_fedora/rdf_node/term_proxy.rb

@@ -17,21 +17,36 @@ module ActiveFedora
       end
 
 
-      def build(attributes=nil)
+      def build(attributes={})
         node = mint_node(attributes)
-        parent.graph.insert([subject, predicate, node.rdf_subject])
+        parent.insert_child(predicate, node)
         reset!
         new_node = target.find { |n| n.rdf_subject == node.rdf_subject}
+        new_node = node unless new_node #if it's a list, the find doesn't work, just use the new node
         new_node.new_record = true
         new_node
       end
 
+      # Remove all matching nodes from the graph
+      def clear
+        parent.query(subject, predicate).each do |solution|
+          # TODO - Recursive delete
+          # Delete everythign we're pointing at.
+          parent.graph.delete([solution.value, nil, nil]) if solution.value.uri?
+        end
+        # Delete all the assertions about this object
+        parent.graph.delete([subject, nil, nil])
+        reset!
+      end
+
       def reset!
         @target = nil
       end
       
-      def mint_node(attributes=nil)
-        new_subject = RDF::Node.new
+      # @param [Hash] attributes
+      # @option attributes id the rdf subject to use for the node, if omitted the new node will be a b-node
+      def mint_node(attributes)
+        new_subject = attributes.key?('id') ? RDF::URI.new(attributes.delete('id')) : RDF::Node.new
         return parent.target_class(predicate).new(parent.graph, new_subject).tap do |node|
           node.attributes = attributes if attributes
         end
@@ -55,30 +70,31 @@ module ActiveFedora
         @target ||= load_values
       end
 
+      # Get the values off of the rdf nodes this proxy targets
       def load_values
         values = []
 
         parent.query(subject, predicate).each do |solution|
           v = solution.value
           v = v.to_s if v.is_a? RDF::Literal
-          if options[:type] == :date
+          if options.type == :date
             v = Date.parse(v)
           end
           # If the user provided options[:class_name], we should query to make sure this 
           # potential solution is of the right RDF.type
-          if options[:class_name]
+          if options.class_name
             klass =  class_from_rdf_type(v)
-            values << v if klass == ActiveFedora.class_from_string(options[:class_name], parent.class)
+            values << v if klass == ActiveFedora.class_from_string(options.class_name, parent.class)
           else
             values << v
           end
         end
 
-        if options[:class_name]
+        if options.class_name
           values = values.map{ |found_subject| class_from_rdf_type(found_subject).new(parent.graph, found_subject)}
         end
         
-        values
+        options.multivalue ? values : values.first
       end
       
       private 
@@ -91,7 +107,7 @@ module ActiveFedora
       # Two classes may be valid for the same predicate (e.g. hasMember)
       # If no RDF.type assertion is found, fall back to using target_class
       def class_from_rdf_type(subject)
-        unless subject.kind_of?(RDF::Node)
+        unless subject.kind_of?(RDF::Node) || subject.kind_of?(RDF::URI)
           raise ArgumentError, "Expected the value of #{predicate} to be an RDF object but it is a #{subject.class} #{subject.inspect}"
         end
         q = RDF::Query.new do

data/lib/active_fedora/rdf_object.rb

@@ -20,11 +20,6 @@ module ActiveFedora
       insert_type_assertion
     end
 
-    def get_values(subject, predicate)
-      predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
-      return TermProxy.new(@graph, @subject, predicate)
-    end
-
     private
     
     def insert_type_assertion

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "6.4.4"
+  VERSION = "6.4.5"
 end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -49,16 +49,24 @@ describe "Nesting attribute behavior of RDFDatastream" do
             accepts_nested_attributes_for :elementList, :extraProperty
           end
           class ElementList
-            include ActiveFedora::RdfObject
+            include ActiveFedora::RdfList
             rdf_type DummyMADS.elementList
             map_predicates do |map|
-              map.topicElement(in: DummyMADS, to: "TopicElement")
+              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
+            accepts_nested_attributes_for :topicElement
+          end
+          class MadsTopicElement
+            include ActiveFedora::RdfObject
+            rdf_type DummyMADS.TopicElement
+            map_predicates do |map|
+              map.elementValue(in: DummyMADS)
+            end
           end
         end
       end
@@ -74,13 +82,13 @@ describe "Nesting attribute behavior of RDFDatastream" do
               '0' =>
               {
                 elementList_attributes: [{
-                  topicElement:"Cosmology"
+                  topicElement_attributes: [{elementValue:"Cosmology"}]
                   }]
               },
               '1' =>
               {
                 elementList_attributes: [{
-                  topicElement:"Quantum Behavior"
+                  topicElement_attributes: {'0' => {elementValue:"Quantum Behavior"}}
                 }]
               }
             },
@@ -97,6 +105,21 @@ describe "Nesting attribute behavior of RDFDatastream" do
         }
       end
 
+      describe "on lists" do
+        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"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+
+        end
+        it "should accept an array" do
+          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
+          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+        end
+      end
+
       it "should create nested objects" do
           # Replace the graph's contents with the Hash
           subject.attributes = params[:myResource]
@@ -110,8 +133,8 @@ describe "Nesting attribute behavior of RDFDatastream" do
           # 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.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
@@ -155,10 +178,9 @@ describe "Nesting attribute behavior of RDFDatastream" do
         subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
 
       end
-      it "should raise an error when the object isn't found" do
-       expect {
-          subject.parts_attributes= [{id: '_:g70192865051320', label: "Universal Joint"}]
-       }.to raise_error ActiveFedora::RecordNotFound
+      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'
       end
     end    
   end

data/spec/unit/active_fedora_spec.rb

@@ -121,5 +121,11 @@ describe ActiveFedora do
     it "should find sibling classes" do
       ActiveFedora.class_from_string("SiblingClass", ParentClass::OtherSiblingClass).should == ParentClass::SiblingClass
     end
+
+    it "should raise a NameError if the class isn't found" do
+      expect {
+        ActiveFedora.class_from_string("FooClass", ParentClass::OtherSiblingClass)
+      }.to raise_error NameError, "uninitialized constant FooClass"
+    end
   end
 end

data/spec/unit/rdf_datastream_spec.rb

@@ -9,7 +9,8 @@ describe ActiveFedora::RDFDatastream do
     before do 
       class MyDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
-          map.title(:in => RDF::DC)
+          map.title(in: RDF::DC)
+          map.description(in: RDF::DC, multivalue: false)
         end
       end
       class MyObj < ActiveFedora::Base
@@ -31,12 +32,25 @@ describe ActiveFedora::RDFDatastream do
     end
 
     it "should allow asserting an empty string" do
-      @obj.descMetadata.title = ['']
-      @obj.descMetadata.title.should == ['']
+      subject.title = ['']
+      subject.title.should == ['']
+    end
+
+    describe "when multivalue: false" do
+      it "should return single values" do
+        subject.description = 'my description'
+        subject.description.should == 'my description'
+      end
+    end
+
+    it "should clear stuff" do
+      subject.title = ['one', 'two', 'three']
+      subject.title.clear
+      subject.graph.query([subject.rdf_subject,  RDF::DC.title, nil]).first.should be_nil
     end
 
     it "should have a list of fields" do
-      MyDatastream.fields.should == [:title]
+      MyDatastream.fields.should == [:title, :description]
     end
   end
 end

data/spec/unit/rdf_list_nested_attributes_spec.rb

@@ -78,6 +78,9 @@ describe ActiveFedora::RdfList do
       topic.elementList.first[0].elementValue.should == ["Baseball"]
       topic.elementList.first[1].should be_kind_of(TopicElement)
       topic.elementList.first[1].elementValue.should == ["Football"]
+
+      # only one rdf:rest rdf:nil
+      topic.graph.query([nil, RDF.rest, RDF.nil]).size.should == 1 
     end
     it "should insert new nodes of varying types into RdfLists (rather than calling .build)" do
       # It's Not clear what the syntax should be when an RDF list contains multiple types of sub-nodes.  
@@ -107,4 +110,4 @@ describe ActiveFedora::RdfList do
       topic.elementList.first[3].elementValue.should == ["Twentieth Century"]
     end
   end
-end
+end

data/spec/unit/rdf_list_spec.rb

@@ -16,6 +16,11 @@ describe ActiveFedora::RdfList do
       end 
       class List 
         include ActiveFedora::RdfList
+        map_predicates do |map|
+          map.topicElement(:in=> MADS, :to =>"TopicElement", :class_name => "TopicElement")
+          map.temporalElement(:in=> MADS, :to =>"TemporalElement", :class_name => "TemporalElement")
+        end
+          
         class TopicElement
           include ActiveFedora::RdfObject
           rdf_type MADS.TopicElement
@@ -100,6 +105,33 @@ END
 
   end
 
+  describe "an empty list" do
+    subject { DemoList.new(double('inner object', :pid=>'foo', :new? =>true)).elementList.build } 
+    it "should have to_ary" do
+      subject.to_ary.should == []
+    end
+  end
+
+  describe "a list that has a constructed element" do
+    let(:ds) { DemoList.new(double('inner object', :pid=>'foo', :new? =>true)) }
+    let(:list) { ds.elementList.build } 
+    let!(:topic) { list.topicElement.build }
+    
+    it "should have to_ary" do
+      list.to_ary.size.should == 1
+      list.to_ary.first.class.should == DemoList::List::TopicElement
+    end
+
+    it "should be able to be cleared" do
+      list.topicElement.build
+      list.topicElement.build
+      list.topicElement.build
+      list.size.should == 4
+      list.clear
+      list.size.should == 0
+    end
+  end
+
   describe "a list with content" do
     subject do
       subject = DemoList.new(double('inner object', :pid=>'foo', :new? =>true), 'descMetadata')
@@ -124,11 +156,13 @@ END
 
       subject
     end
-   it "should have a subject" do
+    it "should have a subject" do
       subject.rdf_subject.to_s.should == "info:fedora/foo"
     end
+
+    let (:list) { subject.elementList.first }
+
     it "should have fields" do
-      list = subject.elementList.first
       list.first.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
       list[1].should be_kind_of DemoList::List::TopicElement
       list[1].elementValue.should == ["Relations with Mexican Americans"]
@@ -137,13 +171,23 @@ END
       list[3].elementValue.should == ["20th century"]
     end
 
+    it "should have each" do
+      foo = []
+      list.each { |n| foo << n.class }
+      foo.should == [RDF::URI, DemoList::List::TopicElement, RDF::URI, DemoList::List::TemporalElement]
+    end
+
+    it "should have to_ary" do
+      ary = list.to_ary
+      ary.size.should == 4
+      ary[1].elementValue.should == ['Relations with Mexican Americans']
+    end
+
     it "should have size" do
-      list = subject.elementList.first
       list.size.should == 4
     end
 
     it "should update fields" do
-      list = subject.elementList.first
       list[3].elementValue = ["1900s"]
       expected_xml =<<END
   <rdf:RDF

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 6.4.4
+  version: 6.4.5
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-30 00:00:00.000000000 Z
+date: 2013-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr
@@ -343,6 +343,7 @@ files:
 - lib/active_fedora/railtie.rb
 - lib/active_fedora/rdf.rb
 - lib/active_fedora/rdf/nested_attributes.rb
+- lib/active_fedora/rdf/node_config.rb
 - lib/active_fedora/rdf_datastream.rb
 - lib/active_fedora/rdf_list.rb
 - lib/active_fedora/rdf_node.rb
@@ -550,7 +551,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: A convenience libary for manipulating documents in the Fedora Repository.