active-fedora 1.2.6 → 1.2.7

data/VERSION

@@ -1 +1 @@
-1.2.6
+1.2.7

data/active-fedora.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{active-fedora}
-  s.version = "1.2.6"
+  s.version = "1.2.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt", "McClain Looney"]
-  s.date = %q{2010-10-27}
+  s.date = %q{2010-11-14}
   s.description = %q{ActiveFedora provides for creating and managing objects in the Fedora Repository Architecture.}
   s.email = %q{matt.zumwalt@yourmediashelf.com}
   s.extra_rdoc_files = [
@@ -220,6 +220,7 @@ Gem::Specification.new do |s|
      "solr/config/solrconfig-1.5.xml",
      "spec/fixtures/changeme155.xml",
      "spec/fixtures/dino.jpg",
+     "spec/fixtures/dino_jpg_no_file_ext",
      "spec/fixtures/hydrangea_fixture_mods_article1.foxml.xml",
      "spec/fixtures/minivan.jpg",
      "spec/fixtures/mods_articles/hydrangea_article1.xml",
@@ -238,6 +239,7 @@ Gem::Specification.new do |s|
      "spec/integration/metadata_datastream_helper_spec.rb",
      "spec/integration/model_spec.rb",
      "spec/integration/mods_article_integration_spec.rb",
+     "spec/integration/nokogiri_datastream_spec.rb",
      "spec/integration/rels_ext_datastream_spec.rb",
      "spec/integration/repository_spec.rb",
      "spec/integration/rf_fedora_object_spec.rb",
@@ -300,6 +302,7 @@ Gem::Specification.new do |s|
      "spec/integration/metadata_datastream_helper_spec.rb",
      "spec/integration/model_spec.rb",
      "spec/integration/mods_article_integration_spec.rb",
+     "spec/integration/nokogiri_datastream_spec.rb",
      "spec/integration/rels_ext_datastream_spec.rb",
      "spec/integration/repository_spec.rb",
      "spec/integration/rf_fedora_object_spec.rb",

data/lib/active_fedora/base.rb

@@ -249,10 +249,19 @@ module ActiveFedora
     # Add the given file as a datastream in the object
     #
     # @param [File] file the file to add
-    # @param [Hash] opts options: :dsid, :label
+    # @param [Hash] opts options: :dsid, :label, :mimeType
     def add_file_datastream(file, opts={})
       label = opts.has_key?(:label) ? opts[:label] : ""
-      ds = ActiveFedora::Datastream.new(:dsLabel => label, :controlGroup => 'M', :blob => file)
+      attrs = {:dsLabel => label, :controlGroup => 'M', :blob => file}
+      if opts.has_key?(:mime_type)
+        attrs.merge!({:mimeType=>opts[:mime_type]})
+      elsif opts.has_key?(:mimeType)
+        attrs.merge!({:mimeType=>opts[:mimeType]})
+      elsif opts.has_key?(:content_type)
+        attrs.merge!({:mimeType=>opts[:content_type]})
+      end
+      
+      ds = ActiveFedora::Datastream.new(attrs)
       opts.has_key?(:dsid) ? ds.dsid=(opts[:dsid]) : nil
       add_datastream(ds)
     end
@@ -345,6 +354,12 @@ module ActiveFedora
       unless named_datastreams_desc.has_key?(name) && named_datastreams_desc[name].has_key?(:type) 
         raise "Failed to add datastream. Named datastream #{name} not defined for object #{pid}." 
       end
+
+      if opts.has_key?(:mime_type)
+        opts.merge!({:content_type=>opts[:mime_type]})
+      elsif opts.has_key?(:mimeType)
+        opts.merge!({:content_type=>opts[:mimeType]})
+      end
       opts.merge!(named_datastreams_desc[name])
         
       label = opts.has_key?(:label) ? opts[:label] : ""
@@ -366,8 +381,8 @@ module ActiveFedora
         if opts[:blob].respond_to?(:content_type)&&!opts[:blob].content_type.nil? && !opts.has_key?(:content_type)
           opts.merge!({:content_type=>opts[:blob].content_type})
         end
-     
-        raise "The blob must respond to content_type or the hash must have :content_type property set" unless opts.has_key?(:content_type)
+
+        raise "The blob must respond to content_type or the hash must have :content_type or :mime_type property set" unless opts.has_key?(:content_type)
         
         #throw error for mimeType mismatch
         if named_datastreams_desc[name].has_key?(:mimeType) && !named_datastreams_desc[name][:mimeType].eql?(opts[:content_type])

data/lib/active_fedora/nokogiri_datastream.rb

@@ -10,8 +10,11 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
   include Solrizer::XML::TerminologyBasedSolrizer # this adds support for calling .to_solr
   
   # extend(OM::XML::Container::ClassMethods)
+
+  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 :ng_xml
+  attr_accessor :ng_xml, :internal_solr_doc
   
   #constructor, calls up to ActiveFedora::Datastream's constructor
   def initialize(attrs=nil)
@@ -79,9 +82,20 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     return xml.to_xml {|config| config.no_declaration}
   end
   
-  #overriding this method just so metadatahelper method does not get called
+  # ** 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)
-    #do nothing for now 
+    #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
   
   def solrize_accessor(accessor_name, accessor_info, opts={})
@@ -109,7 +123,6 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
         solrize_accessor(child_accessor_name, child_accessor_info, opts={:solr_doc=>solr_doc, :parents=>parents+[{accessor_name=>nodeset.index(node)}] })
       end
     end
-    
   end
   
   def solrize_node(node, accessor_pointer, solr_doc = Solr::Document.new)
@@ -124,7 +137,195 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
       solr_doc << Solr::Field.new(hierarchical_field_name => node.text)
     end
   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?
+    begin
+     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.data_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.data_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.data_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.data_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.data_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
+    rescue Exception => e
+      #just do nothing since term does not exist and return emtpy values
+      raise e
+    end
+    values
+  end
+
+  def generate_solr_symbol(base, data_type)
+    Solrizer::XML::TerminologyBasedSolrizer.default_field_mapper.solr_name(base.to_sym, 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=Solr::Document.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
+  # @param [Hash] params The params specifying which fields to update and their new values.  Format: term_pointer => {index => value, ...}
+  #         term_pointer must be a valind OM Term pointer (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 will return something like this:
+  # <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"
@@ -134,6 +335,7 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     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))
@@ -153,4 +355,24 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     term_values(*field_key)
   end
 
-end
+  # Override the method in  OM::XML::TermValueOperators so that returns an error if we have loaded from solr since it should be read-only
+  #
+  # example term values hash: {[{":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"] }
+  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.load_instance to first load object via Fedora instead."
+    else
+      om_update_values(params)
+    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
+end

data/lib/active_fedora/semantic_node.rb

@@ -586,6 +586,22 @@ module ActiveFedora
         self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(name,object)}
         self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(name,object)}
       end 
+
+      #  ** EXPERIMENTAL **
+      #  Similar to +create_named_relationship_methods+ except we are merely creating an alias for outbound portion of bidirectional
+      #
+      #  ====Example
+      #    has_bidirectional_relationship "members", :has_collection_member, :is_member_of_collection
+      #    
+      #    Method members_outbound_append and members_outbound_remove added
+      #    This method will create members_append which does same thing as members_outbound_append
+      #    and will create members_remove which does same thing as members_outbound_remove
+      def create_bidirectional_named_relationship_methods(name,outbound_name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(outbound_name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(outbound_name,object)}
+      end
     
       def create_inbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
@@ -650,6 +666,7 @@ module ActiveFedora
       end
       
       # Generates relationship finders for predicates that point in both directions
+      # and registers predicate relationships for each direction.
       #
       # @name Name of the relationship method(s) to create
       # @outbound_predicate Predicate used in outbound relationships
@@ -659,9 +676,12 @@ module ActiveFedora
       def create_bidirectional_relationship_finders(name, outbound_predicate, inbound_predicate, opts={})
         inbound_method_name = name.to_s+"_inbound"
         outbound_method_name = name.to_s+"_outbound"
-        create_outbound_relationship_finders(outbound_method_name, outbound_predicate, opts)
-        create_inbound_relationship_finders(inbound_method_name, inbound_predicate, opts)
-        
+        has_relationship(outbound_method_name, outbound_predicate, opts)
+        has_relationship(inbound_method_name, inbound_predicate, opts.merge!(:inbound=>true))
+
+        #create methods that mirror the outbound append and remove with our bidirectional name, assume just add and remove locally        
+        create_bidirectional_named_relationship_methods(name,outbound_method_name)
+
         class_eval <<-END
         def #{name}(opts={})
           if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr

data/lib/fedora/connection.rb

@@ -188,11 +188,14 @@ module Fedora
     # remote service and resources.
     def http
       http = Net::HTTP.new(@site.host, @site.port)
-      if(@site.is_a?(URI::HTTPS) && !SSL_CLIENT_CERT_FILE.nil? && !SSL_CLIENT_KEY_FILE.nil? && !SSL_CLIENT_KEY_PASS.nil?)
+      if(@site.is_a?(URI::HTTPS))
         http.use_ssl = true
-        http.cert = OpenSSL::X509::Certificate.new( File.read(SSL_CLIENT_CERT_FILE) )
-        http.key = OpenSSL::PKey::RSA.new( File.read(SSL_CLIENT_KEY_FILE), SSL_CLIENT_KEY_PASS )
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        if (defined?(SSL_CLIENT_CERT_FILE) && !SSL_CLIENT_CERT_FILE.nil? && defined?(SSL_CLIENT_KEY_FILE) && !SSL_CLIENT_KEY_FILE.nil? && defined?(SSL_CLIENT_KEY_PASS) && !SSL_CLIENT_KEY_PASS.nil?)
+          http.cert = OpenSSL::X509::Certificate.new( File.read(SSL_CLIENT_CERT_FILE) )
+          http.key = OpenSSL::PKey::RSA.new( File.read(SSL_CLIENT_KEY_FILE), SSL_CLIENT_KEY_PASS )
+        end
       end
       http
     end
@@ -212,4 +215,4 @@ module Fedora
       (@site.user || @site.password ? { 'Authorization' => 'Basic ' + ["#{@site.user}:#{ @site.password}"].pack('m').delete("\r\n") } : {})
     end
   end
-end
+end

data/spec/fixtures/hydrangea_fixture_mods_article1.foxml.xml

@@ -89,13 +89,31 @@ xsi:schemaLocation="info:fedora/fedora-system:def/foxml# http://www.fedora.info/
           <displayForm>NAME AS IT APPEARS</displayForm>
           <affiliation>FACULTY, UNIVERSITY</affiliation>    
           <role> 
-              <roleTerm authority="marcrelator" type="text">creator</roleTerm>
+              <roleTerm authority="marcrelator" type="text">Creator</roleTerm>
           </role>
+      </name>
+      <name type="personal">
+          <namePart type="family">Lacks</namePart>
+          <namePart type="given">Henrietta</namePart>
+          <displayForm>HeLa</displayForm>
+          <affiliation>Baltimore</affiliation>    
           <role>
-              <roleTerm type="text">submitter</roleTerm>
+              <roleTerm authority="marcrelator" type="text">Contributor</roleTerm>
           </role>
       </name>
-
+      <name type="corporate"> 
+        <namePart>NSF</namePart> 
+        <role> 
+          <roleTerm authority="marcrelator" type="text">Funder</roleTerm> 
+        </role> 
+      </name> 
+      <name type="conference"> 
+        <namePart>some conference</namePart> 
+        <role> 
+          <roleTerm authority="marcrelator" type="text">Host</roleTerm> 
+        </role> 
+      </name>
+      
       <typeOfResource>text</typeOfResource>
       <genre authority="local">journal article</genre>
 
@@ -158,7 +176,7 @@ xsi:schemaLocation="info:fedora/fedora-system:def/foxml# http://www.fedora.info/
 <foxml:xmlContent>
 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
   <rdf:Description rdf:about="info:fedora/hydrangea:fixture_mods_article1">
-    <hasModel xmlns="info:fedora/fedora-system:def/relations-external#" rdf:resource="info:fedora/afmodel:ModsArticle"></hasModel>
+    <hasModel xmlns="info:fedora/fedora-system:def/relations-external#" rdf:resource="info:fedora/afmodel:HydrangeaArticle"></hasModel>
   </rdf:Description>
 </rdf:RDF>
 </foxml:xmlContent>
@@ -167,13 +185,42 @@ xsi:schemaLocation="info:fedora/fedora-system:def/foxml# http://www.fedora.info/
 <foxml:datastream ID="rightsMetadata" STATE="A" CONTROL_GROUP="X" VERSIONABLE="true">
 <foxml:datastreamVersion ID="rightsMetadata.0" LABEL="" CREATED="2010-06-17T19:56:23.335Z" MIMETYPE="text/xml" SIZE="19">
 <foxml:xmlContent>
-  <fields>
-    <discover_access_group>public</discover_access_group>
-    <read_access_group>public</read_access_group>
-    <edit_access_group>researcher</edit_access_group>
-    <edit_access_group>archivist</edit_access_group>
-    <edit_access>researcher1</edit_access>
-  </fields>
+  <rightsMetadata xmlns="http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1">
+      <copyright>
+        <human>(c)2009 The Hydra Project</human>
+        <human type="someSpecialisedType">Blah Blah</human>
+        <human type="aDifferentType">More blah</human>
+    		<machine><a rel="license" href="http://creativecommons.org/licenses/publicdomain/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/publicdomain/88x31.png" /></a><br />This work is in the <a rel="license" href="http://creativecommons.org/licenses/publicdomain/">Public Domain</a>.</machine>
+  	</copyright>
+  	<access type="discover">
+  		<human></human>
+  		<machine>
+  			<policy>hydra-policy:4502</policy>
+        <group>public</group>
+      </machine>
+  	</access>
+  	<access type="read">
+  		<human></human>
+  		<machine>
+        <group>public</group>
+      </machine>
+  	</access>
+  	<access type="edit">
+  		<human></human>
+  		<machine>
+  		  <person>researcher1</person>
+        <group>archivist</group>
+  		</machine>        
+  	</access>
+    <access type="etc">
+            <!-- etc -->
+    </access>
+  	<use>
+  		<human>You are free to re-distribute this object, but you cannot change it or sell it. </human>
+  		<machine><a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/us/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-nc-nd/3.0/us/88x31.png" /></a><br />This <span xmlns:dc="http://purl.org/dc/elements/1.1/" href="http://purl.org/dc/dcmitype/Sound" rel="dc:type">work</span> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-nd/3.0/us/">Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License</a>.</machine>
+  	</use>
+
+  </rightsMetadata>
 </foxml:xmlContent>
 </foxml:datastreamVersion>
 </foxml:datastream>