active-fedora 6.0.0.pre10 → 6.0.0.rc1

data/History.txt

@@ -4,6 +4,14 @@ Added support for RDF lists
 RDF does not index terms by default
 count is now a scoped query.
 
+5.6.1
+Fixed delegating enumerable methods (join, [], each_with_index, to_a, etc) on an RdfNode::TermProxy
+
+5.6.0
+Upgrade to rubydora 1.3.0, which prevents unnecessary loading of datastream content.
+#35 fix passing :sort argument to ActiveFedora::Base#find
+Better support for ruby 2.0 (delegating inspect within RdfNode::TermProxy)
+
 5.5.2
 #25 When multiple has_many relationships share a predicate, the solr_query should use class_name to distinguish the sets.
 

data/lib/active_fedora/datastream.rb

@@ -26,7 +26,7 @@ module ActiveFedora
     def metadata?
       false
     end
-    
+
     def validate_content_present
       has_content?
     end

data/lib/active_fedora/nokogiri_datastream.rb

@@ -1,405 +1,10 @@
-require "nokogiri"
-require  "om"
-require "solrizer/xml"
-
 #this class represents a xml metadata datastream
 module ActiveFedora
-  class NokogiriDatastream < Datastream
-
-    before_save do
-      if content.blank?
-        logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
-        false
-      end
-    end
-    
-    include OM::XML::Document
-    include OM::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
-    
-    def self.default_attributes
-      super.merge(:controlGroup => 'X', :mimeType => 'text/xml')
-    end
-
-    # Create an instance of this class based on xml content
-    # @param [String, File, Nokogiri::XML::Node] xml the xml content to build from
-    # @param [ActiveFedora::NokogiriDatastream] tmpl the Datastream object that you are building @default a new instance of this class
-    # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
-    def self.from_xml(xml, tmpl=nil)
-      tmpl = self.new if tmpl.nil?  ## This path is used only for unit testing (e.g. MarpaDCDatastream.from_xml(fixture("data.xml")) )
-
-      if !xml.present?
-        tmpl.ng_xml = self.xml_template
-      elsif xml.kind_of? Nokogiri::XML::Node || xml.kind_of?(Nokogiri::XML::Document)
-        tmpl.ng_xml = xml
-      else
-        tmpl.ng_xml = Nokogiri::XML::Document.parse(xml)
-      end
-
-      tmpl.ng_xml_doesnt_change!
-
-      return tmpl
-    end
-    
-    def self.xml_template
-      Nokogiri::XML::Document.parse("<xml/>")
-    end
-
-    def ng_xml 
-      @ng_xml ||= begin
-      if new?
-        ## Load up the template
-        self.class.xml_template
-      else
-        Nokogiri::XML::Document.parse(datastream_content)
-      end
-      end
-    end
-    
-    def ng_xml=(new_xml)
-      case new_xml 
-      when Nokogiri::XML::Document
-        self.content=new_xml.to_xml
-      when  Nokogiri::XML::Node 
-        ## Cast a fragment to a document
-        self.content=new_xml.to_s
-      when String 
-        self.content=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
-    end
-    
-    # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
-    def ng_xml_will_change!
-      changed_attributes['ng_xml'] = nil
-    end
-
-    def ng_xml_doesnt_change!
-      changed_attributes.delete('ng_xml')
-    end
-    
-    # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
-    def ng_xml_changed?
-      changed_attributes.has_key? 'ng_xml'
-    end
-
-    # Indicates that this datastream has metadata content. 
-    # @return true 
-    def metadata?
-      true
-    end
-
-    def content
-      to_xml
-    end
-
-    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)
-      super(@ng_xml.to_s)
-    end
-
-    def content_changed?
-      return false if new? and !xml_loaded
+  class NokogiriDatastream < OmDatastream
+    def initialize(digital_object=nil, dsid=nil, options={})
+      Deprecation.warn("NokogiriDatastream is deprecated and will be removed in active-fedora 7.0, use OmDatastream instead", caller)
       super
     end
-
-    def to_xml(xml = nil)
-      xml = self.ng_xml if xml.nil?
-      ng_xml = self.ng_xml
-      if ng_xml.respond_to?(:root) && ng_xml.root.nil? && self.class.respond_to?(:root_property_ref) && !self.class.root_property_ref.nil?
-        ng_xml = self.class.generate(self.class.root_property_ref, "")
-        if xml.root.nil?
-          xml = ng_xml
-        end
-      end
-
-      unless xml == ng_xml || ng_xml.root.nil?
-        if xml.kind_of?(Nokogiri::XML::Document)
-            xml.root.add_child(ng_xml.root)
-        elsif xml.kind_of?(Nokogiri::XML::Node)
-            xml.add_child(ng_xml.root)
-        else
-            raise "You can only pass instances of Nokogiri::XML::Node into this method.  You passed in #{xml}"
-        end
-      end
-      
-      return xml.to_xml {|config| config.no_declaration}.strip
-    end
-    
-    # ** Experimental **
-    #
-    # This method is called by ActiveFedora::Base.load_instance_from_solr
-    # in order to initialize a nokogiri datastreams values from a solr document.
-    # This method merely sets the internal_solr_doc to the document passed in.
-    # Then any calls to get_values get values from the solr document on demand
-    # instead of directly from the xml stored in Fedora.  This should be used
-    # for read-only purposes only, and instances where you want to improve performance by
-    # getting data from solr instead of Fedora.
-    # 
-    # See ActiveFedora::Base.load_instance_from_solr and +get_values_from_solr+ for more information.
-    def from_solr(solr_doc)
-      #just initialize internal_solr_doc since any value retrieval will be done via lazy loading on this doc on-demand
-      @internal_solr_doc = solr_doc
-    end
-
-
-    # ** Experimental **
-    # This method is called by +get_values+ if this datastream has been initialized by calling from_solr method via
-    # ActiveFedora::Base.load_instance_from_solr. This method retrieves values from a preinitialized @internal_solr_doc instead of xml.
-    # This makes the datastream read-only and this method is not intended to be used in any other case.
-    #
-    # Values are retrieved from the @internal_solr_doc on-demand instead of via xml preloaded into memory.  
-    # A term_pointer is passed in and if it contains hierarchical indexes it will detect which solr field values need to be returned.
-    #
-    # ====Example 1 (non-hierarchical term_pointer):
-    #
-    #   term_pointer = [:image, :title_set, :title]
-    #
-    #   Returns value of "image_title_set_title_t" in @internal_solr_doc
-    #
-    # ====Example 2 (hierarchical term_pointer that contains one or more indexes):
-    #   term_pointer = [:image, {:title_set=>1}, :title]
-    #
-    #   relevant xml:  
-    #         <image>
-    #           <title_set>
-    #             <title>Title 1</title>
-    #           </title_set>
-    #         </image>
-    #         <image>
-    #           <title_set>
-    #             <title>Title 2</title>
-    #           </title_set>
-    #           <title_set>
-    #             <title>Title 3</title>
-    #           </title_set>
-    #         </image>
-    #    
-    #   Repeating element nodes are indexed and will be stored in solr as follows:
-    #     image_0_title_set_0_title_t = "Title 1"
-    #     image_1_title_set_0_title_t = "Title 2"
-    #     image_1_title_set_1_title_t = "Title 3"
-    #
-    #   Even though no image element index is specified, only the second image element has two title_set elements so the expected return value is
-    #     ["Title 3"]
-    #
-    #   While loading from solr the xml hierarchy is not immediately apparent so we must detect first how many image elements with a title_set element exist
-    #   and then check which of those elements have a second title element.
-    #   
-    #   As this nokogiri datastream is indexed in solr, a value at each level in the tree will be stored independently and therefore 
-    #   if 'image_0_title_set_0_title_t' exists in solr 'image_0_title_set_t' will also exist in solr.  
-    #   So, we will build up the relevant solr names incrementally for a given term_pointer.  The last element in the
-    #   solr_name will not contain an index.
-    #
-    #   It then will do the following:
-    #     Because no index is supplied for :image it will detect which indexes exist in solr
-    #        image_0_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
-    #        image_1_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
-    #        image_2_title_set_t   (not found and stop checking indexes for image)
-    #     After iteration 1:
-    #        bases = ["image_0_title_set","image_1_title_set"]
-    #
-    #     Two image nodes were found and next sees index of 1 supplied for title_set so just uses index of 1 building off bases found in previous iteration
-    #        image_0_title_set_1_title_t (not found remove 'image_0_title_set' from base solr_name list)
-    #        image_1_title_set_1_title_t (found and replace 'image_1_title_set' with new base 'image_1_title_set_1_title') 
-    #      
-    #     After iteration 2:
-    #        bases = ["image_1_title_set_1_title"]
-    #     It always looks ahead one element so we check if any elements are after title.  There are not any other elements so we are done iterating.
-    #        returns @internal_solr_doc["image_1_title_set_1_title_t"]
-    # @param [Array] term_pointer Term pointer similar to an xpath ie. [:image, :title_set, :title]
-    # @return [Array] If no values are found an empty Array is returned.
-    def get_values_from_solr(*term_pointer)
-      values = []
-      solr_doc = @internal_solr_doc
-      return values if solr_doc.nil?
-      term = self.class.terminology.retrieve_term(*OM.pointers_to_flat_array(term_pointer, false))
-      #check if hierarchical term pointer
-      if is_hierarchical_term_pointer?(*term_pointer)
-         # if we are hierarchical need to detect all possible node values that exist
-         # we do this by building up the possible solr names parent by parent and/or child by child
-         # if an index is supplied for any node in the pointer it will be used
-         # otherwise it will include all nodes and indexes that exist in solr
-         bases = []
-         #add first item in term_pointer as start of bases
-         # then iterate through possible nodes that might exist
-         term_pointer.first.kind_of?(Hash) ? bases << term_pointer.first.keys.first : bases << term_pointer.first
-         for i in 1..(term_pointer.length-1)
-           #iterate in reverse so that we can modify the bases array while iterating
-           (bases.length-1).downto(0) do |j|
-             current_last = (term_pointer[i].kind_of?(Hash) ? term_pointer[i].keys.first : term_pointer[i])
-             if (term_pointer[i-1].kind_of?(Hash))
-               #just use index supplied instead of trying possibilities
-               index = term_pointer[i-1].values.first
-               solr_name_base = OM::XML::Terminology.term_hierarchical_name({bases[j]=>index},current_last)
-               solr_name = generate_solr_symbol(solr_name_base, term.type)
-               bases.delete_at(j)
-               #insert the new solr name base if found
-               bases.insert(j,solr_name_base) if has_solr_name?(solr_name,solr_doc)
-             else
-               #detect how many nodes exist
-               index = 0
-               current_base = bases[j]
-               bases.delete_at(j)
-               solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
-               solr_name = generate_solr_symbol(solr_name_base, term.type)
-               #check for indexes that exist until we find all nodes
-               while has_solr_name?(solr_name,solr_doc) do
-                 #only reinsert if it exists
-                 bases.insert(j,solr_name_base)
-                 index = index + 1
-                 solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
-                 solr_name = generate_solr_symbol(solr_name_base, term.type)
-               end
-             end
-           end
-         end
-
-         #all existing applicable solr_names have been found and we can now grab all values and build up our value array
-         bases.each do |base|
-           field_name = generate_solr_symbol(base.to_sym, term.type)
-           value = (solr_doc[field_name].nil? ? solr_doc[field_name.to_s]: solr_doc[field_name])
-           unless value.nil?
-             value.is_a?(Array) ? values.concat(value) : values << value
-           end
-         end
-      else
-         #this is not hierarchical and we can simply look for the solr name created using the terms without any indexes
-         generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
-         generic_field_name = generate_solr_symbol(generic_field_name_base, term.type)
-         value = (solr_doc[generic_field_name].nil? ? solr_doc[generic_field_name.to_s]: solr_doc[generic_field_name])
-         unless value.nil?
-           value.is_a?(Array) ? values.concat(value) : values << value
-         end
-      end
-      values
-    end
-
-    def generate_solr_symbol(base, data_type)
-      ActiveFedora::SolrService.solr_name(base.to_sym, type: data_type)
-    end
-
-    # ** Experimental **
-    #@return [Boolean] true if either the key for name exists in solr or if its string value exists
-    #@param [String] name Name of key to look for
-    #@param [Solr::Document] solr_doc Solr doc to query
-    def has_solr_name?(name, solr_doc=Hash.new)
-      !solr_doc[name].nil? || !solr_doc[name.to_s].nil?
-    end
-
-    # ** Experimental **
-    #@return true if the term_pointer contains an index
-    # ====Example:
-    #     [:image, {:title_set=>1}, :title] return true
-    #     [:image, :title_set, :title]      return false
-    def is_hierarchical_term_pointer?(*term_pointer)
-      if term_pointer.length>1
-        term_pointer.each do |pointer|
-          if pointer.kind_of?(Hash)
-            return true
-          end
-        end
-      end
-      return false
-    end
-
-    # Update field values within the current datastream using {#update_values}, which is a wrapper for {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values}
-    # Ignores any fields from params that this datastream's Terminology doesn't recognize    
-    #
-    # @param [Hash] params The params specifying which fields to update and their new values.  The syntax of the params Hash is the same as that expected by 
-    #         term_pointers must be a valid OM Term pointers (ie. [:name]).  Strings will be ignored.
-    # @param [Hash] opts This is not currently used by the datastream-level update_indexed_attributes method
-    #
-    # Example: 
-    #   @mods_ds.update_indexed_attributes( {[{":person"=>"0"}, "role"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} })
-    #   => {"person_0_role"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}}
-    #
-    #   @mods_ds.to_xml # (the following is an approximation)
-    #   <mods>
-    #     <mods:name type="person">
-    #     <mods:role>
-    #       <mods:roleTerm>role1</mods:roleTerm>
-    #     </mods:role>
-    #     <mods:role>
-    #       <mods:roleTerm>role2</mods:roleTerm>
-    #     </mods:role>
-    #     <mods:role>
-    #       <mods:roleTerm>role3</mods:roleTerm>
-    #     </mods:role>
-    #     </mods:name>
-    #   </mods>
-    def update_indexed_attributes(params={}, opts={})    
-      if self.class.terminology.nil?
-        raise "No terminology is set for this NokogiriDatastream class.  Cannot perform update_indexed_attributes"
-      end
-      # remove any fields from params that this datastream doesn't recognize    
-      # make sure to make a copy of params so not to modify hash that might be passed to other methods
-      current_params = params.clone
-      current_params.delete_if do |term_pointer,new_values| 
-        if term_pointer.kind_of?(String)
-          logger.warn "WARNING: #{dsid} ignoring {#{term_pointer.inspect} => #{new_values.inspect}} because #{term_pointer.inspect} is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it."
-          true
-        else
-          !self.class.terminology.has_term?(*OM.destringify(term_pointer))
-        end
-      end
-
-      result = {}
-      unless current_params.empty?
-        result = update_values( current_params )
-      end
-      
-      return result
-    end
-    
-    def get_values(field_key,default=[])
-      term_values(*field_key)
-    end
-
-
-    def find_by_terms(*termpointer)
-      super
-    end
-
-    # Update values in the datastream's xml
-    # This wraps {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values} so that returns an error if we have loaded from solr since datastreams loaded that way should be read-only
-    #
-    # @example Updating multiple values with a Hash of Term pointers and values
-    #   ds.update_values( {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] } )
-    #   => {"person_0_role_text"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, "person_1_role_text"=>{"0"=>"otherrole1", "1"=>"otherrole2"}} 
-    def update_values(params={})
-      if @internal_solr_doc
-        raise "No update performed, this object was initialized via Solr instead of Fedora and is therefore read-only.  Please utilize ActiveFedora::Base.find to first load object via Fedora instead."
-      else
-        ng_xml_will_change!
-        result = om_update_values(params)
-        return result
-      end
-    end
-
-    #override OM::XML::term_values so can lazy load from solr if this datastream initialized using +from_solr+
-    def term_values(*term_pointer)
-      if @internal_solr_doc
-        #lazy load values from solr on demand
-        get_values_from_solr(*term_pointer)
-      else
-        om_term_values(*term_pointer)
-      end
-    end
-
-    def xml_loaded
-      instance_variable_defined? :@ng_xml
-    end
-    
   end
 end
 

data/lib/active_fedora/om_datastream.rb

@@ -1,7 +1,402 @@
 require  "om"
 
 module ActiveFedora
-  class OmDatastream < NokogiriDatastream
+  class OmDatastream < Datastream
     # right now, OmDatastream is just an alias for NokogiriDatastream
+
+    before_save do
+      if content.blank?
+        logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
+        false
+      end
+    end
+    
+    include OM::XML::Document
+    include OM::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
+    
+    def self.default_attributes
+      super.merge(:controlGroup => 'X', :mimeType => 'text/xml')
+    end
+
+    # Create an instance of this class based on xml content
+    # @param [String, File, Nokogiri::XML::Node] xml the xml content to build from
+    # @param [ActiveFedora::NokogiriDatastream] tmpl the Datastream object that you are building @default a new instance of this class
+    # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
+    def self.from_xml(xml, tmpl=nil)
+      tmpl = self.new if tmpl.nil?  ## This path is used only for unit testing (e.g. MarpaDCDatastream.from_xml(fixture("data.xml")) )
+
+      if !xml.present?
+        tmpl.ng_xml = self.xml_template
+      elsif xml.kind_of? Nokogiri::XML::Node || xml.kind_of?(Nokogiri::XML::Document)
+        tmpl.ng_xml = xml
+      else
+        tmpl.ng_xml = Nokogiri::XML::Document.parse(xml)
+      end
+
+      tmpl.ng_xml_doesnt_change!
+
+      return tmpl
+    end
+    
+    def self.xml_template
+      Nokogiri::XML::Document.parse("<xml/>")
+    end
+
+    def ng_xml 
+      @ng_xml ||= begin
+      if new?
+        ## Load up the template
+        self.class.xml_template
+      else
+        Nokogiri::XML::Document.parse(datastream_content)
+      end
+      end
+    end
+    
+    def ng_xml=(new_xml)
+      case new_xml 
+      when Nokogiri::XML::Document
+        self.content=new_xml.to_xml
+      when  Nokogiri::XML::Node 
+        ## Cast a fragment to a document
+        self.content=new_xml.to_s
+      when String 
+        self.content=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
+    end
+    
+    # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
+    def ng_xml_will_change!
+      changed_attributes['ng_xml'] = nil
+    end
+
+    def ng_xml_doesnt_change!
+      changed_attributes.delete('ng_xml')
+    end
+    
+    # don't want content eagerly loaded by proxy, so implementing methods that would be implemented by define_attribute_methods 
+    def ng_xml_changed?
+      changed_attributes.has_key? 'ng_xml'
+    end
+
+    # Indicates that this datastream has metadata content. 
+    # @return true 
+    def metadata?
+      true
+    end
+
+    def content
+      to_xml
+    end
+
+    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)
+      super(@ng_xml.to_s)
+    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
+      if ng_xml.respond_to?(:root) && ng_xml.root.nil? && self.class.respond_to?(:root_property_ref) && !self.class.root_property_ref.nil?
+        ng_xml = self.class.generate(self.class.root_property_ref, "")
+        if xml.root.nil?
+          xml = ng_xml
+        end
+      end
+
+      unless xml == ng_xml || ng_xml.root.nil?
+        if xml.kind_of?(Nokogiri::XML::Document)
+            xml.root.add_child(ng_xml.root)
+        elsif xml.kind_of?(Nokogiri::XML::Node)
+            xml.add_child(ng_xml.root)
+        else
+            raise "You can only pass instances of Nokogiri::XML::Node into this method.  You passed in #{xml}"
+        end
+      end
+      
+      return xml.to_xml {|config| config.no_declaration}.strip
+    end
+    
+    # ** Experimental **
+    #
+    # This method is called by ActiveFedora::Base.load_instance_from_solr
+    # in order to initialize a nokogiri datastreams values from a solr document.
+    # This method merely sets the internal_solr_doc to the document passed in.
+    # Then any calls to get_values get values from the solr document on demand
+    # instead of directly from the xml stored in Fedora.  This should be used
+    # for read-only purposes only, and instances where you want to improve performance by
+    # getting data from solr instead of Fedora.
+    # 
+    # See ActiveFedora::Base.load_instance_from_solr and +get_values_from_solr+ for more information.
+    def from_solr(solr_doc)
+      #just initialize internal_solr_doc since any value retrieval will be done via lazy loading on this doc on-demand
+      @internal_solr_doc = solr_doc
+    end
+
+
+    # ** Experimental **
+    # This method is called by +get_values+ if this datastream has been initialized by calling from_solr method via
+    # ActiveFedora::Base.load_instance_from_solr. This method retrieves values from a preinitialized @internal_solr_doc instead of xml.
+    # This makes the datastream read-only and this method is not intended to be used in any other case.
+    #
+    # Values are retrieved from the @internal_solr_doc on-demand instead of via xml preloaded into memory.  
+    # A term_pointer is passed in and if it contains hierarchical indexes it will detect which solr field values need to be returned.
+    #
+    # ====Example 1 (non-hierarchical term_pointer):
+    #
+    #   term_pointer = [:image, :title_set, :title]
+    #
+    #   Returns value of "image_title_set_title_t" in @internal_solr_doc
+    #
+    # ====Example 2 (hierarchical term_pointer that contains one or more indexes):
+    #   term_pointer = [:image, {:title_set=>1}, :title]
+    #
+    #   relevant xml:  
+    #         <image>
+    #           <title_set>
+    #             <title>Title 1</title>
+    #           </title_set>
+    #         </image>
+    #         <image>
+    #           <title_set>
+    #             <title>Title 2</title>
+    #           </title_set>
+    #           <title_set>
+    #             <title>Title 3</title>
+    #           </title_set>
+    #         </image>
+    #    
+    #   Repeating element nodes are indexed and will be stored in solr as follows:
+    #     image_0_title_set_0_title_t = "Title 1"
+    #     image_1_title_set_0_title_t = "Title 2"
+    #     image_1_title_set_1_title_t = "Title 3"
+    #
+    #   Even though no image element index is specified, only the second image element has two title_set elements so the expected return value is
+    #     ["Title 3"]
+    #
+    #   While loading from solr the xml hierarchy is not immediately apparent so we must detect first how many image elements with a title_set element exist
+    #   and then check which of those elements have a second title element.
+    #   
+    #   As this nokogiri datastream is indexed in solr, a value at each level in the tree will be stored independently and therefore 
+    #   if 'image_0_title_set_0_title_t' exists in solr 'image_0_title_set_t' will also exist in solr.  
+    #   So, we will build up the relevant solr names incrementally for a given term_pointer.  The last element in the
+    #   solr_name will not contain an index.
+    #
+    #   It then will do the following:
+    #     Because no index is supplied for :image it will detect which indexes exist in solr
+    #        image_0_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
+    #        image_1_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
+    #        image_2_title_set_t   (not found and stop checking indexes for image)
+    #     After iteration 1:
+    #        bases = ["image_0_title_set","image_1_title_set"]
+    #
+    #     Two image nodes were found and next sees index of 1 supplied for title_set so just uses index of 1 building off bases found in previous iteration
+    #        image_0_title_set_1_title_t (not found remove 'image_0_title_set' from base solr_name list)
+    #        image_1_title_set_1_title_t (found and replace 'image_1_title_set' with new base 'image_1_title_set_1_title') 
+    #      
+    #     After iteration 2:
+    #        bases = ["image_1_title_set_1_title"]
+    #     It always looks ahead one element so we check if any elements are after title.  There are not any other elements so we are done iterating.
+    #        returns @internal_solr_doc["image_1_title_set_1_title_t"]
+    # @param [Array] term_pointer Term pointer similar to an xpath ie. [:image, :title_set, :title]
+    # @return [Array] If no values are found an empty Array is returned.
+    def get_values_from_solr(*term_pointer)
+      values = []
+      solr_doc = @internal_solr_doc
+      return values if solr_doc.nil?
+      term = self.class.terminology.retrieve_term(*OM.pointers_to_flat_array(term_pointer, false))
+      #check if hierarchical term pointer
+      if is_hierarchical_term_pointer?(*term_pointer)
+         # if we are hierarchical need to detect all possible node values that exist
+         # we do this by building up the possible solr names parent by parent and/or child by child
+         # if an index is supplied for any node in the pointer it will be used
+         # otherwise it will include all nodes and indexes that exist in solr
+         bases = []
+         #add first item in term_pointer as start of bases
+         # then iterate through possible nodes that might exist
+         term_pointer.first.kind_of?(Hash) ? bases << term_pointer.first.keys.first : bases << term_pointer.first
+         for i in 1..(term_pointer.length-1)
+           #iterate in reverse so that we can modify the bases array while iterating
+           (bases.length-1).downto(0) do |j|
+             current_last = (term_pointer[i].kind_of?(Hash) ? term_pointer[i].keys.first : term_pointer[i])
+             if (term_pointer[i-1].kind_of?(Hash))
+               #just use index supplied instead of trying possibilities
+               index = term_pointer[i-1].values.first
+               solr_name_base = OM::XML::Terminology.term_hierarchical_name({bases[j]=>index},current_last)
+               solr_name = generate_solr_symbol(solr_name_base, term.type)
+               bases.delete_at(j)
+               #insert the new solr name base if found
+               bases.insert(j,solr_name_base) if has_solr_name?(solr_name,solr_doc)
+             else
+               #detect how many nodes exist
+               index = 0
+               current_base = bases[j]
+               bases.delete_at(j)
+               solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
+               solr_name = generate_solr_symbol(solr_name_base, term.type)
+               #check for indexes that exist until we find all nodes
+               while has_solr_name?(solr_name,solr_doc) do
+                 #only reinsert if it exists
+                 bases.insert(j,solr_name_base)
+                 index = index + 1
+                 solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
+                 solr_name = generate_solr_symbol(solr_name_base, term.type)
+               end
+             end
+           end
+         end
+
+         #all existing applicable solr_names have been found and we can now grab all values and build up our value array
+         bases.each do |base|
+           field_name = generate_solr_symbol(base.to_sym, term.type)
+           value = (solr_doc[field_name].nil? ? solr_doc[field_name.to_s]: solr_doc[field_name])
+           unless value.nil?
+             value.is_a?(Array) ? values.concat(value) : values << value
+           end
+         end
+      else
+         #this is not hierarchical and we can simply look for the solr name created using the terms without any indexes
+         generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
+         generic_field_name = generate_solr_symbol(generic_field_name_base, term.type)
+         value = (solr_doc[generic_field_name].nil? ? solr_doc[generic_field_name.to_s]: solr_doc[generic_field_name])
+         unless value.nil?
+           value.is_a?(Array) ? values.concat(value) : values << value
+         end
+      end
+      values
+    end
+
+    def generate_solr_symbol(base, data_type)
+      ActiveFedora::SolrService.solr_name(base.to_sym, type: data_type)
+    end
+
+    # ** Experimental **
+    #@return [Boolean] true if either the key for name exists in solr or if its string value exists
+    #@param [String] name Name of key to look for
+    #@param [Solr::Document] solr_doc Solr doc to query
+    def has_solr_name?(name, solr_doc=Hash.new)
+      !solr_doc[name].nil? || !solr_doc[name.to_s].nil?
+    end
+
+    # ** Experimental **
+    #@return true if the term_pointer contains an index
+    # ====Example:
+    #     [:image, {:title_set=>1}, :title] return true
+    #     [:image, :title_set, :title]      return false
+    def is_hierarchical_term_pointer?(*term_pointer)
+      if term_pointer.length>1
+        term_pointer.each do |pointer|
+          if pointer.kind_of?(Hash)
+            return true
+          end
+        end
+      end
+      return false
+    end
+
+    # Update field values within the current datastream using {#update_values}, which is a wrapper for {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values}
+    # Ignores any fields from params that this datastream's Terminology doesn't recognize    
+    #
+    # @param [Hash] params The params specifying which fields to update and their new values.  The syntax of the params Hash is the same as that expected by 
+    #         term_pointers must be a valid OM Term pointers (ie. [:name]).  Strings will be ignored.
+    # @param [Hash] opts This is not currently used by the datastream-level update_indexed_attributes method
+    #
+    # Example: 
+    #   @mods_ds.update_indexed_attributes( {[{":person"=>"0"}, "role"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"} })
+    #   => {"person_0_role"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}}
+    #
+    #   @mods_ds.to_xml # (the following is an approximation)
+    #   <mods>
+    #     <mods:name type="person">
+    #     <mods:role>
+    #       <mods:roleTerm>role1</mods:roleTerm>
+    #     </mods:role>
+    #     <mods:role>
+    #       <mods:roleTerm>role2</mods:roleTerm>
+    #     </mods:role>
+    #     <mods:role>
+    #       <mods:roleTerm>role3</mods:roleTerm>
+    #     </mods:role>
+    #     </mods:name>
+    #   </mods>
+    def update_indexed_attributes(params={}, opts={})    
+      if self.class.terminology.nil?
+        raise "No terminology is set for this NokogiriDatastream class.  Cannot perform update_indexed_attributes"
+      end
+      # remove any fields from params that this datastream doesn't recognize    
+      # make sure to make a copy of params so not to modify hash that might be passed to other methods
+      current_params = params.clone
+      current_params.delete_if do |term_pointer,new_values| 
+        if term_pointer.kind_of?(String)
+          logger.warn "WARNING: #{dsid} ignoring {#{term_pointer.inspect} => #{new_values.inspect}} because #{term_pointer.inspect} is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it."
+          true
+        else
+          !self.class.terminology.has_term?(*OM.destringify(term_pointer))
+        end
+      end
+
+      result = {}
+      unless current_params.empty?
+        result = update_values( current_params )
+      end
+      
+      return result
+    end
+    
+    def get_values(field_key,default=[])
+      term_values(*field_key)
+    end
+
+
+    def find_by_terms(*termpointer)
+      super
+    end
+
+    # Update values in the datastream's xml
+    # This wraps {http://rdoc.info/gems/om/1.2.4/OM/XML/TermValueOperators#update_values-instance_method OM::TermValueOperators#update_values} so that returns an error if we have loaded from solr since datastreams loaded that way should be read-only
+    #
+    # @example Updating multiple values with a Hash of Term pointers and values
+    #   ds.update_values( {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] } )
+    #   => {"person_0_role_text"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, "person_1_role_text"=>{"0"=>"otherrole1", "1"=>"otherrole2"}} 
+    def update_values(params={})
+      if @internal_solr_doc
+        raise "No update performed, this object was initialized via Solr instead of Fedora and is therefore read-only.  Please utilize ActiveFedora::Base.find to first load object via Fedora instead."
+      else
+        ng_xml_will_change!
+        result = om_update_values(params)
+        return result
+      end
+    end
+
+    #override OM::XML::term_values so can lazy load from solr if this datastream initialized using +from_solr+
+    def term_values(*term_pointer)
+      if @internal_solr_doc
+        #lazy load values from solr on demand
+        get_values_from_solr(*term_pointer)
+      else
+        om_term_values(*term_pointer)
+      end
+    end
+
+    def xml_loaded
+      instance_variable_defined? :@ng_xml
+    end
+    
   end
-end
+end

data/lib/active_fedora/rdf_node/term_proxy.rb

@@ -4,9 +4,9 @@ module ActiveFedora
 
       attr_reader :graph, :subject, :predicate, :options
 
-      delegate :class, :to_s, :==, :kind_of?, :each, :map, :empty?, :as_json, 
-               :is_a?, :to_ary, :inspect, :first, :last, :include?, :count, 
-               :size, :join, :[], :to => :values
+      delegate :class, :to_s, :==, :kind_of?, :each, :each_with_index, :map,
+               :empty?, :as_json, :is_a?, :to_ary, :to_a, :inspect, :first,
+               :last, :include?, :count, :size, :join, :[], :to => :values
 
       # @param graph RDF::Graph
       # @param subject RDF::URI

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-  VERSION = "6.0.0.pre10"
+  VERSION = "6.0.0.rc1"
 end

data/spec/unit/datastream_spec.rb

@@ -42,6 +42,7 @@ describe ActiveFedora::Datastream do
       @test_datastream.validate_content_present.should be_false
       @test_datastream.content = "<foo><xmlelement/></foo>"
       @test_datastream.validate_content_present.should be_true
+      @test_datastream.should_not be_external
     end
 
     it "should expect a dsLocation on an External (E) datastream" do
@@ -50,6 +51,7 @@ describe ActiveFedora::Datastream do
       @test_datastream.validate_content_present.should be_false
       @test_datastream.dsLocation = "http://example.com/test/content/abcd"
       @test_datastream.validate_content_present.should be_true
+      @test_datastream.should be_external
     end
 
     it "should expect a dsLocation on a Redirect (R) datastream" do

data/spec/unit/ntriples_datastream_spec.rb

@@ -45,6 +45,10 @@ describe ActiveFedora::NtriplesRDFDatastream do
       @subject.title.count.should == 1 
       @subject.title.size.should == 1 
       @subject.title[0].should == "Title of work" 
+      @subject.title.to_a.should == ["Title of work"]
+      val = []
+      @subject.title.each_with_index {|v, i| val << "#{i}. #{v}"}
+      val.should == ["0. Title of work"]
     end
 
     it "should return fields that are not TermProxies" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 6.0.0.pre10
+  version: 6.0.0.rc1
   prerelease: 6
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-04 00:00:00.000000000 Z
+date: 2013-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr