active-fedora 2.2.0 → 2.2.1

data/lib/active_fedora.rb

@@ -21,6 +21,7 @@ require 'active_fedora/qualified_dublin_core_datastream.rb'
 require 'active_fedora/relationship.rb'
 require 'active_fedora/rels_ext_datastream.rb'
 require 'active_fedora/semantic_node.rb'
+require 'active_fedora/version.rb'
 
 SOLR_DOCUMENT_ID = ActiveFedora::SolrService.id_field unless defined?(SOLR_DOCUMENT_ID)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
@@ -28,7 +29,7 @@ ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
 module ActiveFedora #:nodoc:
   
   class << self
-    attr_accessor :solr_config, :fedora_config, :predicate_config_path
+    attr_accessor :solr_config, :fedora_config
   end
   
   # The configuration hash that gets used by RSolr.connect
@@ -104,6 +105,10 @@ module ActiveFedora #:nodoc:
   def self.predicate_config
     @predicate_config_path
   end
+
+  def self.version
+    ActiveFedora::VERSION
+  end
 end
 
 

data/lib/active_fedora/base.rb

@@ -178,7 +178,7 @@ module ActiveFedora
     # Adds datastream to the object.  Saves the datastream to fedora upon adding.
     # If datastream does not have a DSID, a unique DSID is generated
     # :prefix option will set the prefix on auto-generated DSID
-    # @returns DSID of the added datastream
+    # @return [String] dsid of the added datastream
     def add_datastream(datastream, opts={})
       datastream.pid = self.pid
       if datastream.dsid == nil || datastream.dsid.empty?
@@ -700,7 +700,7 @@ module ActiveFedora
     # Relationships Management
     #
     
-    # @returns Hash of relationships, as defined by SemanticNode
+    # @return [Hash] relationships hash, as defined by SemanticNode
     # Rely on rels_ext datastream to track relationships array
     # Overrides accessor for relationships array used by SemanticNode.
     # If outbound_only is false, inbound relationships will be included.
@@ -790,7 +790,9 @@ module ActiveFedora
       @inner_object.label = new_label
     end
 
-
+    # Create an instance of the current Model from the given FOXML
+    # This method is used when you call load_instance on a Model
+    # @param [Nokogiri::XML::Document] doc the FOXML of the object
     def self.deserialize(doc) #:nodoc:
       if doc.instance_of?(REXML::Document)
         pid = doc.elements['/foxml:digitalObject'].attributes['PID']
@@ -864,8 +866,8 @@ module ActiveFedora
     end
 
     # Return a Hash representation of this object where keys in the hash are appropriate Solr field names.
-    # @solr_doc (optional) Hash to insert the fields into
-    # @opts (optional) Hash
+    # @param [Hash] solr_doc (optional) Hash to insert the fields into
+    # @param [Hash] opts (optional) 
     # If opts[:model_only] == true, the base object metadata and the RELS-EXT datastream will be omitted.  This is mainly to support shelver, which calls .to_solr for each model an object subscribes to. 
     def to_solr(solr_doc = Hash.new, opts={})
       unless opts[:model_only]

data/lib/active_fedora/datastream.rb

@@ -54,12 +54,13 @@ module ActiveFedora
       dsid.gsub(/\./, '%2e')
     end
     
-    #has this datastream been modified since it was last saved?
+    # Test whether this datastream been modified since it was last saved?
     def dirty?
       @dirty
     end
   
-    #saves this datastream into fedora.
+    # Save the datastream into fedora.
+    # Also triggers {#before_save} and {#after_save} callbacks
     def save
       before_save
       result = Fedora::Repository.instance.save(self)
@@ -67,21 +68,21 @@ module ActiveFedora
       result
     end
     
-    def before_save # :nodoc:
+    # Callback.  Does nothing by default.  Override this to insert behaviors before the save method.
+    def before_save 
       #check_concurrency
     end
     
-    # @tmpl ActiveFedora::Datastream
-    # @node Nokogiri::XML::Node
+    # Populate a Datastream object based on the "datastream" node from a FOXML file
+    # @param [ActiveFedora::Datastream] tmpl the Datastream object that you are building
+    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file
     def self.from_xml(tmpl, node)
-      node.xpath("foxml:xmlContent/fields").each do |f|
-        # tmpl.send("#{f.name}_append", f.content)
-      end
       tmpl.instance_variable_set(:@dirty, false)
       tmpl.control_group= node['CONTROL_GROUP']
       tmpl
     end
     
+    # Callback.  Override this to insert behaviors after the save method.  By default, sets self.dirty = false
     def after_save
       self.dirty = false
     end

data/lib/active_fedora/metadata_datastream.rb

@@ -1,5 +1,11 @@
 module ActiveFedora
-  #this class represents a MetadataDatastream, a special case of ActiveFedora::Datastream
+  # A legacy class that creates and updates simple xml documents
+  # For much greater flexibility, use {ActiveFedora::NokogiriDatastream} instead.
+  # @example The simple, flat xml structure used by these datastreams
+  #   <fields>
+  #     <title>Foo</title>
+  #     <author>Bar</author>
+  #   </fields>
   class MetadataDatastream < Datastream
     
     include ActiveFedora::MetadataDatastreamHelper
@@ -124,8 +130,9 @@ module ActiveFedora
       end
     end
     
-    # @tmpl ActiveFedora::MetadataDatastream
-    # @node Nokogiri::XML::Node
+    # Populate a MetadataDatastream object based on the "datastream" node from a FOXML file
+    # @param [ActiveFedora::Datastream] tmpl the Datastream object that you are building
+    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file.  Assumes that the content of this datastream is that of an ActiveFedora MetadataDatastream (<fields>...</fields>)
     def self.from_xml(tmpl, node) # :nodoc:
       node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/fields/node()").each do |f|
           tmpl.send("#{f.name}_append", f.text) unless f.class == Nokogiri::XML::Text

data/lib/active_fedora/model.rb

@@ -42,10 +42,14 @@ module ActiveFedora
     #     *appends val to the values array.
     module ClassMethods
 
-      # Load an instance with the following pid. Note that you can actually
-      # pass an pid into this method, regardless of Fedora model type, and
-      # ActiveFedora will try to parse the results into the current type
-      # of self, which may or may not be what you want.
+      # Retrieve the Fedora object with the given pid and deserialize it as an instance of the current model
+      # Note that you can actually pass a pid into this method, regardless of Fedora model type, and
+      # ActiveFedora will try to parse the results into the current type of self, which may or may not be what you want.
+      #
+      # @param [String] pid of the object to load
+      #
+      # @example this will return an instance of Book, even if the object hydra:dataset1 asserts that it is a Dataset
+      #   Book.load_instance("hydra:dataset1") 
       def load_instance(pid)
         Fedora::Repository.instance.find_model(pid, self)
       end

data/lib/active_fedora/nokogiri_datastream.rb

@@ -23,8 +23,9 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     self.class.from_xml(blob, self)
   end
 
-  # @xml String, File or Nokogiri::XML::Node
-  # @tmpl ActiveFedora::MetadataDatastream
+  # 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::MetadataDatastream] 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=self.new) # :nodoc:
     if xml.nil?
@@ -264,35 +265,37 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     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.
+  # 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.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>
+  #   @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
+    # 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)
@@ -316,9 +319,12 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     term_values(*field_key)
   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
+  # 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 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"] }
+  # @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.load_instance to first load object via Fedora instead."

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -27,8 +27,9 @@ module ActiveFedora
       self.blob = self.to_dc_xml
     end
     
-    # @tmpl ActiveFedora::Datastream
-    # @node Nokogiri::XML::Node
+    # Populate a QualifiedDublinCoreDatastream object based on the "datastream" node from a FOXML file
+    # @param [ActiveFedora::Datastream] tmpl the Datastream object that you are building
+    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file.  Assumes that the content of this datastream is that of an ActiveFedora QualifiedDublinCoreDatastream 
     def self.from_xml(tmpl, node) # :nodoc:
      tmpl.fields.each do |z|
        fname = z.first

data/lib/active_fedora/rels_ext_datastream.rb

@@ -29,14 +29,21 @@ module ActiveFedora
       EOL
     end
     
-    # @tmpl ActiveFedora::MetadataDatastream
-    # @node Nokogiri::XML::Node
+    # Populate a RelsExtDatastream object based on the "datastream" node from a FOXML file
+    # Assumes that the datastream contains RDF XML from a Fedora RELS-EXT datastream 
+    # @param [ActiveFedora::MetadataDatastream] tmpl the Datastream object that you are populating
+    # @param [Nokogiri::XML::Node] node the "foxml:datastream" node from a FOXML file
     def self.from_xml(tmpl, node) 
       # node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/rdf:RDF/rdf:Description/*").each do |f|
       node.xpath("./foxml:datastreamVersion[last()]/foxml:xmlContent/rdf:RDF/rdf:Description/*", {"rdf"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#", "foxml"=>"info:fedora/fedora-system:def/foxml#"}).each do |f|
-          ns_mapping = self.predicate_mappings[f.namespace.href]
-          predicate = ns_mapping ?  ns_mapping.invert[f.name] : nil
-          predicate = "#{f.namespace.prefix}_#{f.name}" if predicate.nil?
+          if f.namespace
+            ns_mapping = self.predicate_mappings[f.namespace.href]
+            predicate = ns_mapping ?  ns_mapping.invert[f.name] : nil
+            predicate = "#{f.namespace.prefix}_#{f.name}" if predicate.nil?
+          else
+            logger.warn "You have a predicate without a namespace #{f.name}. Verify your rels-ext is correct."
+            predicate = "#{f.name}"
+          end
           object = f["resource"] ? f["resource"] : f.inner_text
           r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>predicate, :object=>object)
           tmpl.add_relationship(r)
@@ -45,6 +52,8 @@ module ActiveFedora
       tmpl
     end
     
+    # Serialize the datastream's RDF relationships to solr
+    # @param [Hash] solr_doc @deafult an empty Hash
     def to_solr(solr_doc = Hash.new)
       self.relationships.each_pair do |subject, predicates|
         if subject == :self || subject == "info:fedora/#{self.pid}"

data/lib/active_fedora/samples.rb

@@ -0,0 +1,3 @@
+# require all of the files in the samples directory
+module Hydra;end
+Dir[File.join(File.dirname(__FILE__), "samples", "*.rb")].each {|f| require f}

data/lib/active_fedora/samples/hydra-mods_article_datastream.rb

@@ -0,0 +1,517 @@
+require "active-fedora"
+module Hydra
+  
+  # This is an example of a NokogiriDatastream that defines a terminology for MODS xml
+  # It focuses on the aspects of MODS that deal with descriptive metadata for published articles
+  # The real version of this Terminology is part of the hydra-head plugin.  See https://github.com/projecthydra/hydra-head/blob/master/lib/hydra/mods_article.rb
+  #
+  # Things to note about the Terminology it defines:
+  #
+  # * Uses :ref terms to repeat the structures of a mods:name with a different @type on the mods:name element
+  # * Defines a term lang_code that maps to "languageTerm[@type=code]"
+  # * Defines a variety of terms, date, last_name, first_name & terms_of_address, that all map to mods:namePart but use varying attributes to distinguish themselves
+  # * Uses proxy terms to define familar terms like start_page and end_page that map to non-intuitive xml structures "extent[@unit=pages]/start" and "extent[@unit=pages]/end"
+  # * Uses proxy terms, publication_url, peer_reviewed, and title, to allow convenient access to frequently used terms 
+  #
+  # Things to note about the additional methods it defines:
+  # 
+  # * Defines a series of templates, person_template, organization_template, etc. for generating a whole set of xml nodes to insert into the document (note: the new OM::TemplateRegistry provides an even better way to do this)
+  # * Defines a custom method, insert_contributor, that uses the Terminology to manipulate xml documents in specialized ways
+  # * Defines a series of relator_term Hashes that can then be used when generating views, etc.  In this case, the Hashes are hard-coded into the Class.  Ideally, they might be read from a configuration file or mixed into the class using a module
+  class ModsArticleDatastream < ActiveFedora::NokogiriDatastream       
+
+    set_terminology do |t|
+      t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+
+
+      t.title_info(:path=>"titleInfo") {
+        t.main_title(:index_as=>[:facetable],:path=>"title", :label=>"title")
+        t.language(:index_as=>[:facetable],:path=>{:attribute=>"lang"})
+      } 
+      t.language{
+        t.lang_code(:index_as=>[:facetable], :path=>"languageTerm", :attributes=>{:type=>"code"})
+      }
+      t.abstract   
+      t.subject {
+        t.topic(:index_as=>[:facetable])
+      }      
+      t.topic_tag(:proxy=>[:subject, :topic])    
+      # t.topic_tag(:index_as=>[:facetable],:path=>"subject", :default_content_path=>"topic")
+      # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
+      t.name_ {
+        # this is a namepart
+        t.namePart(:type=>:string, :label=>"generic name")
+        # affiliations are great
+        t.affiliation
+        t.institution(:path=>"affiliation", :index_as=>[:facetable], :label=>"organization")
+        t.displayForm
+        t.role(:ref=>[:role])
+        t.description(:index_as=>[:facetable])
+        t.date(:path=>"namePart", :attributes=>{:type=>"date"})
+        t.last_name(:path=>"namePart", :attributes=>{:type=>"family"})
+        t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+        t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        t.computing_id
+      }
+      # lookup :person, :first_name        
+      t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable])
+      t.department(:proxy=>[:person,:description],:index_as=>[:facetable])
+      t.organization(:ref=>:name, :attributes=>{:type=>"corporate"}, :index_as=>[:facetable])
+      t.conference(:ref=>:name, :attributes=>{:type=>"conference"}, :index_as=>[:facetable])
+      t.role {
+        t.text(:path=>"roleTerm",:attributes=>{:type=>"text"})
+        t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
+      }
+      t.journal(:path=>'relatedItem', :attributes=>{:type=>"host"}) {
+        t.title_info(:index_as=>[:facetable],:ref=>[:title_info])
+        t.origin_info(:path=>"originInfo") {
+          t.publisher
+          t.date_issued(:path=>"dateIssued")
+          t.issuance(:index_as=>[:facetable])
+        }
+        t.issn(:path=>"identifier", :attributes=>{:type=>"issn"})
+        t.issue(:path=>"part") {
+          t.volume(:path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+          t.level(:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number")
+          t.extent
+          t.pages(:path=>"extent", :attributes=>{:unit=>"pages"}) {
+            t.start
+            t.end
+          }
+          t.start_page(:proxy=>[:pages, :start])
+          t.end_page(:proxy=>[:pages, :end])
+          t.publication_date(:path=>"date")
+        }
+      }
+      t.note
+      t.location(:path=>"location") {
+        t.url(:path=>"url")
+      }
+      t.publication_url(:proxy=>[:location,:url])
+      t.peer_reviewed(:proxy=>[:journal,:origin_info,:issuance], :index_as=>[:facetable])
+      t.title(:proxy=>[:mods,:title_info, :main_title])
+      t.journal_title(:proxy=>[:journal, :title_info, :main_title])
+    end
+    
+    # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
+    def self.xml_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.mods(:version=>"3.3", "xmlns:xlink"=>"http://www.w3.org/1999/xlink",
+           "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+           "xmlns"=>"http://www.loc.gov/mods/v3",
+           "xsi:schemaLocation"=>"http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-3.xsd") {
+             xml.titleInfo(:lang=>"") {
+               xml.title
+             }
+             xml.name(:type=>"personal") {
+               xml.namePart(:type=>"given")
+               xml.namePart(:type=>"family")
+               xml.affiliation
+               xml.computing_id
+               xml.description
+               xml.role {
+                 xml.roleTerm("Author", :authority=>"marcrelator", :type=>"text")
+               }
+             }
+             xml.typeOfResource
+             xml.genre(:authority=>"marcgt")
+             xml.language {
+               xml.languageTerm(:authority=>"iso639-2b", :type=>"code")
+             }
+             xml.abstract
+             xml.subject {
+               xml.topic
+             }
+             xml.relatedItem(:type=>"host") {
+               xml.titleInfo {
+                 xml.title
+               }
+               xml.identifier(:type=>"issn")
+               xml.originInfo {
+                 xml.publisher
+                 xml.dateIssued
+                 xml.issuance
+               }
+               xml.part {
+                 xml.detail(:type=>"volume") {
+                   xml.number
+                 }
+                 xml.detail(:type=>"number") {
+                   xml.number
+                 }
+                 xml.extent(:unit=>"pages") {
+                   xml.start
+                   xml.end
+                 }
+                 xml.date
+               }
+             }
+             xml.location {
+               xml.url
+             }
+        }
+      end
+      return builder.doc
+    end
+    
+    # Generates a new Person node
+    def self.person_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.name(:type=>"personal") {
+          xml.namePart(:type=>"family")
+          xml.namePart(:type=>"given")
+          xml.affiliation
+          xml.computing_id
+          xml.description
+          xml.role {
+            xml.roleTerm("Author", :type=>"text")
+          }
+        }
+      end
+      return builder.doc.root
+    end
+
+    def self.full_name_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.full_name(:type => "personal")
+      end
+      return builder.doc.root
+    end
+
+    # Generates a new Organization node
+    # Uses mods:name[@type="corporate"]
+    def self.organization_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.name(:type=>"corporate") {
+          xml.namePart
+          xml.role {
+            xml.roleTerm(:authority=>"marcrelator", :type=>"text")
+          }                          
+        }
+      end
+      return builder.doc.root
+    end
+    
+    # Generates a new Conference node
+    def self.conference_template
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.name(:type=>"conference") {
+          xml.namePart
+          xml.role {
+            xml.roleTerm(:authority=>"marcrelator", :type=>"text")
+          }                          
+        }
+      end
+      return builder.doc.root
+    end
+    
+    # Inserts a new contributor (mods:name) into the mods document
+    # creates contributors of type :person, :organization, or :conference
+    def insert_contributor(type, opts={})
+      case type.to_sym 
+      when :person
+        node = Hydra::ModsArticleDatastream.person_template
+        nodeset = self.find_by_terms(:person)
+      when :organization
+        node = Hydra::ModsArticleDatastream.organization_template
+        nodeset = self.find_by_terms(:organization)
+      when :conference
+        node = Hydra::ModsArticleDatastream.conference_template
+        nodeset = self.find_by_terms(:conference)
+      else
+        ActiveFedora.logger.warn("#{type} is not a valid argument for Hydra::ModsArticleDatastream.insert_contributor")
+        node = nil
+        index = nil
+      end
+      
+      unless nodeset.nil?
+        if nodeset.empty?
+          self.ng_xml.root.add_child(node)
+          index = 0
+        else
+          nodeset.after(node)
+          index = nodeset.length
+        end
+        self.dirty = true
+      end
+      
+      return node, index
+    end
+    
+    # Remove the contributor entry identified by @contributor_type and @index
+    def remove_contributor(contributor_type, index)
+      self.find_by_terms( {contributor_type.to_sym => index.to_i} ).first.remove
+      self.dirty = true
+    end
+    
+    def self.common_relator_terms
+       {"aut" => "Author",
+        "clb" => "Collaborator",
+        "com" => "Compiler",
+        "ctb" => "Contributor",
+        "cre" => "Creator",
+        "edt" => "Editor",
+        "ill" => "Illustrator",
+        "oth" => "Other",
+        "trl" => "Translator",
+        }
+    end
+    
+    def self.person_relator_terms
+      {"aut" => "Author",
+       "clb" => "Collaborator",
+       "com" => "Compiler",
+       "cre" => "Creator",
+       "ctb" => "Contributor",
+       "edt" => "Editor",
+       "ill" => "Illustrator",
+       "res" => "Researcher",
+       "rth" => "Research team head",
+       "rtm" => "Research team member",
+       "trl" => "Translator"
+       }
+    end
+    
+    def self.conference_relator_terms
+      {
+        "hst" => "Host"
+      }
+    end
+    
+    def self.organization_relator_terms
+      {
+        "fnd" => "Funder",
+        "hst" => "Host"
+      }
+    end
+    
+    def self.dc_relator_terms
+       {"acp" => "Art copyist",
+        "act" => "Actor",
+        "adp" => "Adapter",
+        "aft" => "Author of afterword, colophon, etc.",
+        "anl" => "Analyst",
+        "anm" => "Animator",
+        "ann" => "Annotator",
+        "ant" => "Bibliographic antecedent",
+        "app" => "Applicant",
+        "aqt" => "Author in quotations or text abstracts",
+        "arc" => "Architect",
+        "ard" => "Artistic director ",
+        "arr" => "Arranger",
+        "art" => "Artist",
+        "asg" => "Assignee",
+        "asn" => "Associated name",
+        "att" => "Attributed name",
+        "auc" => "Auctioneer",
+        "aud" => "Author of dialog",
+        "aui" => "Author of introduction",
+        "aus" => "Author of screenplay",
+        "aut" => "Author",
+        "bdd" => "Binding designer",
+        "bjd" => "Bookjacket designer",
+        "bkd" => "Book designer",
+        "bkp" => "Book producer",
+        "bnd" => "Binder",
+        "bpd" => "Bookplate designer",
+        "bsl" => "Bookseller",
+        "ccp" => "Conceptor",
+        "chr" => "Choreographer",
+        "clb" => "Collaborator",
+        "cli" => "Client",
+        "cll" => "Calligrapher",
+        "clt" => "Collotyper",
+        "cmm" => "Commentator",
+        "cmp" => "Composer",
+        "cmt" => "Compositor",
+        "cng" => "Cinematographer",
+        "cnd" => "Conductor",
+        "cns" => "Censor",
+        "coe" => "Contestant -appellee",
+        "col" => "Collector",
+        "com" => "Compiler",
+        "cos" => "Contestant",
+        "cot" => "Contestant -appellant",
+        "cov" => "Cover designer",
+        "cpc" => "Copyright claimant",
+        "cpe" => "Complainant-appellee",
+        "cph" => "Copyright holder",
+        "cpl" => "Complainant",
+        "cpt" => "Complainant-appellant",
+        "cre" => "Creator",
+        "crp" => "Correspondent",
+        "crr" => "Corrector",
+        "csl" => "Consultant",
+        "csp" => "Consultant to a project",
+        "cst" => "Costume designer",
+        "ctb" => "Contributor",
+        "cte" => "Contestee-appellee",
+        "ctg" => "Cartographer",
+        "ctr" => "Contractor",
+        "cts" => "Contestee",
+        "ctt" => "Contestee-appellant",
+        "cur" => "Curator",
+        "cwt" => "Commentator for written text",
+        "dfd" => "Defendant",
+        "dfe" => "Defendant-appellee",
+        "dft" => "Defendant-appellant",
+        "dgg" => "Degree grantor",
+        "dis" => "Dissertant",
+        "dln" => "Delineator",
+        "dnc" => "Dancer",
+        "dnr" => "Donor",
+        "dpc" => "Depicted",
+        "dpt" => "Depositor",
+        "drm" => "Draftsman",
+        "drt" => "Director",
+        "dsr" => "Designer",
+        "dst" => "Distributor",
+        "dtc" => "Data contributor ",
+        "dte" => "Dedicatee",
+        "dtm" => "Data manager ",
+        "dto" => "Dedicator",
+        "dub" => "Dubious author",
+        "edt" => "Editor",
+        "egr" => "Engraver",
+        "elg" => "Electrician ",
+        "elt" => "Electrotyper",
+        "eng" => "Engineer",
+        "etr" => "Etcher",
+        "exp" => "Expert",
+        "fac" => "Facsimilist",
+        "fld" => "Field director ",
+        "flm" => "Film editor",
+        "fmo" => "Former owner",
+        "fpy" => "First party",
+        "fnd" => "Funder",
+        "frg" => "Forger",
+        "gis" => "Geographic information specialist ",
+        "grt" => "Graphic technician",
+        "hnr" => "Honoree",
+        "hst" => "Host",
+        "ill" => "Illustrator",
+        "ilu" => "Illuminator",
+        "ins" => "Inscriber",
+        "inv" => "Inventor",
+        "itr" => "Instrumentalist",
+        "ive" => "Interviewee",
+        "ivr" => "Interviewer",
+        "lbr" => "Laboratory ",
+        "lbt" => "Librettist",
+        "ldr" => "Laboratory director ",
+        "led" => "Lead",
+        "lee" => "Libelee-appellee",
+        "lel" => "Libelee",
+        "len" => "Lender",
+        "let" => "Libelee-appellant",
+        "lgd" => "Lighting designer",
+        "lie" => "Libelant-appellee",
+        "lil" => "Libelant",
+        "lit" => "Libelant-appellant",
+        "lsa" => "Landscape architect",
+        "lse" => "Licensee",
+        "lso" => "Licensor",
+        "ltg" => "Lithographer",
+        "lyr" => "Lyricist",
+        "mcp" => "Music copyist",
+        "mfr" => "Manufacturer",
+        "mdc" => "Metadata contact",
+        "mod" => "Moderator",
+        "mon" => "Monitor",
+        "mrk" => "Markup editor",
+        "msd" => "Musical director",
+        "mte" => "Metal-engraver",
+        "mus" => "Musician",
+        "nrt" => "Narrator",
+        "opn" => "Opponent",
+        "org" => "Originator",
+        "orm" => "Organizer of meeting",
+        "oth" => "Other",
+        "own" => "Owner",
+        "pat" => "Patron",
+        "pbd" => "Publishing director",
+        "pbl" => "Publisher",
+        "pdr" => "Project director",
+        "pfr" => "Proofreader",
+        "pht" => "Photographer",
+        "plt" => "Platemaker",
+        "pma" => "Permitting agency",
+        "pmn" => "Production manager",
+        "pop" => "Printer of plates",
+        "ppm" => "Papermaker",
+        "ppt" => "Puppeteer",
+        "prc" => "Process contact",
+        "prd" => "Production personnel",
+        "prf" => "Performer",
+        "prg" => "Programmer",
+        "prm" => "Printmaker",
+        "pro" => "Producer",
+        "prt" => "Printer",
+        "pta" => "Patent applicant",
+        "pte" => "Plaintiff -appellee",
+        "ptf" => "Plaintiff",
+        "pth" => "Patent holder",
+        "ptt" => "Plaintiff-appellant",
+        "rbr" => "Rubricator",
+        "rce" => "Recording engineer",
+        "rcp" => "Recipient",
+        "red" => "Redactor",
+        "ren" => "Renderer",
+        "res" => "Researcher",
+        "rev" => "Reviewer",
+        "rps" => "Repository",
+        "rpt" => "Reporter",
+        "rpy" => "Responsible party",
+        "rse" => "Respondent-appellee",
+        "rsg" => "Restager",
+        "rsp" => "Respondent",
+        "rst" => "Respondent-appellant",
+        "rth" => "Research team head",
+        "rtm" => "Research team member",
+        "sad" => "Scientific advisor",
+        "sce" => "Scenarist",
+        "scl" => "Sculptor",
+        "scr" => "Scribe",
+        "sds" => "Sound designer",
+        "sec" => "Secretary",
+        "sgn" => "Signer",
+        "sht" => "Supporting host",
+        "sng" => "Singer",
+        "spk" => "Speaker",
+        "spn" => "Sponsor",
+        "spy" => "Second party",
+        "srv" => "Surveyor",
+        "std" => "Set designer",
+        "stl" => "Storyteller",
+        "stm" => "Stage manager",
+        "stn" => "Standards body",
+        "str" => "Stereotyper",
+        "tcd" => "Technical director",
+        "tch" => "Teacher",
+        "ths" => "Thesis advisor",
+        "trc" => "Transcriber",
+        "trl" => "Translator",
+        "tyd" => "Type designer",
+        "tyg" => "Typographer",
+        "vdg" => "Videographer",
+        "voc" => "Vocalist",
+        "wam" => "Writer of accompanying material",
+        "wdc" => "Woodcutter",
+        "wde" => "Wood -engraver",
+        "wit" => "Witness"}
+      end
+    
+      def self.valid_child_types
+        ["data", "supporting file", "profile", "lorem ipsum", "dolor"]
+      end
+
+    def to_solr(solr_doc=Hash.new)
+      super(solr_doc)
+            
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "object_type_facet", "Article")
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "mods_journal_title_info_facet", "Unknown") if solr_doc["mods_journal_title_info_facet"].nil? 
+
+      solr_doc
+    end
+  end
+end