solr_ead 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p125@solr_ead"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.14.3 (version)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in solr_ead.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Adam Wead
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+# SolrEad
+
+SolrEad is a gem that indexes your ead documents into Solr.  From there, you can use other
+Solr-based applications to search and display your finding aids.  It originated as some
+code that I used to index ead into Blacklight, but this gem does not require you to use
+Blacklight.  You can use this gem with any Solr-based app.
+
+SolrEad uses OM (Opinionated Metadata) to define terms in your ead xml, then uses Solrizer
+to create solr fields from those terms.  An indexer is included that has basic create,
+update and delete methods for getting your documents in and out of solr via the RSolr gem.
+
+The default term definitions are all based on eads created with Archivist's Toolkit, so
+whatever conventions AT has in its ead will be manifested here.  However, you are able to
+override this definitions with your own to meet any specific local needs.
+
+## Indexing
+
+SolrEad's default way of indexing a single ead document is to create one solr document for
+the initial part of the ead and then separate documents for each component node.  You may
+also elect to use a simple indexing option which creates only one solr document per ead
+document.
+
+For more information on indexing, see the documentation for SolrEad::Indexer.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'solr_ead'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself:
+
+    $ gem install solr_ead
+
+## Usage
+
+    $ rake solr_ead:index FILE=/path/to/your/ead.xml
+
+You can also do this via the command line:
+
+    > indexer = SolrEad::Indexer.new
+    > indexer.create(File.new("path/to/your/ead.xml))
+
+### Usage with Blacklight
+
+This code originated in a Blacklight application and some of its default solr fields
+reflect a Blacklight-style solr implementation.  For example, certain facet fields such as
+subject_topic_facet and title_display will appear in your solr index by default.  If you
+are trying out the gem within a default Blacklight installation, you should be able to
+index your ead without any modifications.  However, the only fields that will appear in
+your search results will be format and title.  In order to make this into working
+solution, you'll need to modify both the definitions of documents and components within
+SolrEad and configure Blacklight's own display and facet fields accordingly.
+
+## Applications
+
+SolrEad is intended to work at the indexing layer of an application, but it can also work
+at the display/presentation layer as well.  You can use the solr fields defined in your OM
+terminology for display; however, formatting information such as italics and boldface is
+not preserved from the original EAD xml.
+
+For those that need to preserve the formatting of their finding aids, you can use XSLT to
+process your EAD for display in your application and use SolrEad to index your finding
+aids for searching.
+
+When creating display pages of your finding aids, you can either use "ready-made" html
+pages created using XSLT, or create the html when the page is requested.  If you opt for
+the latter, you can store the ead xml in a solr field.  To do this, add a new solr field
+under the to_solr method of your OM terminology for the ead document:
+
+    solr_doc.merge!({"xml_display" => self.to_xml})
+
+This will create the solr field "xml_display" containing the complete ead xml. Then you
+will be able to apply any xslt processing you wish.  Other solutions are possible using
+xml from the document as well as the component, depending on the needs of your
+application.
+
+## Customization
+
+Chances are the default definitions are not sufficient for your needs.  If you want to
+create your own definitions for documents and components, here's what you can do.
+
+### Writing a custom document definition
+
+Under lib or another directory of your choice, create the file custom_document.rb with the
+following content:
+
+    class CustomDocument < SolrEad::Document
+
+      set_terminology do |t|
+        t.root(:path="ead", :index_as = [:not_searchable])
+        t.eadid
+
+        # Add additional term definitions here
+
+      end
+
+      # Optionally, you may tweak other solr fields here.  Otherwise, you can leave this
+      # method out of your definition.
+      def to_solr(solr_doc = Hash.new)
+        super(solr_doc)
+      end
+
+    end
+
+From the console, index you ead document using your new definition.
+
+    > file = "path/to/ead.xml"
+    > indexer = SolrEad::Indexer.new(:document=>"CustomDocument")
+    > indexer.create(file)
+
+### Adding custom methods
+
+Suppose you want to add some custom methods that perform additional manipulations of
+your solr fields after they've been pulled from your ead.  You can create a module
+for all your specialized methods and add it to your ead document.
+
+    module MyEadBehaviors
+
+      def special_process(field)
+        # manipulate your field here
+        return field
+      end
+
+    end
+
+Then, include your module in your own custom document and call the method during to_solr:
+
+    class CustomDocument < SolrEad::Document
+
+      include MyEadBehaviors
+
+      # terminology goes here...
+
+      def to_solr(solr_doc = Hash.new)
+        super(solr_doc)
+        solr_doc.merge!({"solr_field" => special_process(self.field_name)})
+      end
+
+    end
+
+Your solr document will now include the field "solr_field" that has taken the term
+"field_name" and processed it with the special_process method.
+
+### Solr schema configurations
+
+SolrEad is designed to work with the solr jetty application that comes with Blacklight.
+However, this doesn't prevent you from using your own solr application.  You can alter the
+way SolrEad creates its solr fields by creating your own mapper.  See the ead_mapper.rb
+file for more info and the solrizer gem for more information on configuring how SolrEad
+creates solr fields.
+
+By default, SolrEad will display series and subseries component documents.  You may,
+however, want to surpress this from search results.  To do this, add the following line to
+your solrconfig.xml file, under the "search" request handler:
+
+    <lst name="appends"><str name="fq">-component_children_b:[TRUE TO *]</str></lst>
+
+## Contributing
+
+If you have questions or have specific needs, let me know. If you have other ideas or
+solutions, please contribute code!
+
+1. Fork SolrEad
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Add your code
+4. Add tests for your code and make sure it doesn't break existing features
+5. Commit your changes (`git commit -am 'Added some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create new Pull Request
+
+## Copyright
+
+Copyright (c) 2012 Adam Wead. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,5 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+Bundler::GemHelper.install_tasks
+# load rake tasks in lib/tasks
+Dir.glob('lib/tasks/*.rake').each { |r| import r }

data/config/solr.yml

@@ -0,0 +1,6 @@
+development:
+  url: http://localhost:8983/solr
+test: &TEST
+  url: http://localhost:8983/solr
+production:
+  url: http://localhost:8080/solr/production

data/lib/ead_mapper.rb

@@ -0,0 +1,22 @@
+class EadMapper < Solrizer::FieldMapper
+
+  id_field 'id'
+  index_as :searchable, :default => true do |t|
+    t.default :suffix => '_t'
+    t.date    :suffix => '_dt'
+    t.string  :suffix => '_t'
+    t.text    :suffix => '_t'
+    t.symbol  :suffix => '_s'
+    t.integer :suffix => '_i'
+    t.long    :suffix => '_l'
+    t.boolean :suffix => '_b'
+    t.float   :suffix => '_f'
+    t.double  :suffix => '_d'
+  end
+  index_as :displayable,           :suffix => '_display'
+  index_as :facetable,             :suffix => '_facet'
+  index_as :sortable,              :suffix => '_sort'
+  index_as :unstemmed_searchable,  :suffix => '_unstem_search'
+  index_as :string,                :suffix => '_s'
+  index_as :z,                     :suffix => '_z'
+end

data/lib/solr_ead/behaviors.rb

@@ -0,0 +1,124 @@
+require "sanitize"
+
+module SolrEad::Behaviors
+
+  # Takes a file as its input and returns a Nokogiri::XML::NodeSet of component <c> nodes
+  #
+  # It'll make an attempt at substituting numbered component levels for non-numbered
+  # ones.
+  def components(file)
+    raw = File.read(file).gsub!(/xmlns=".*"/, '')
+    raw.gsub!(/c[0-9]{2,2}/,"c")
+    xml = Nokogiri::XML(raw)
+    return xml.xpath("//c")
+  end
+
+  # Used in conjunction with #components, this takes a single Nokogiri::XML::Element
+  # representing an <c> node from an ead document, and returns a Nokogiri::XML::Document
+  # with any child <c> nodes removed.
+  # == Example
+  # If I input this Nokogiri::XML::Element
+  #   <c>
+  #     <did>etc</did>
+  #     <scopecontent>etc</scopecontent>
+  #     <c>etc</c>
+  #     <c>etc</c>
+  #   </c>
+  # Then I should get back the following Nokogiri::XML::Document
+  #   <c>
+  #     <did>etc</did>
+  #     <scopecontent>etc</scopecontent>
+  #   </c>
+  def prep(node)
+    part = Nokogiri::XML(node.to_s)
+    part.xpath("/*/c").each { |e| e.remove }
+    return part
+  end
+
+  # Because the solr documents created from individual components have been removed from
+  # the hierarchy of their original ead, we need to be able to reconstruct the order
+  # in which they appeared, as well as their location within the hierarchy.
+  #
+  # This method takes a single Nokogiri::XMl::Node as its argument that represents a
+  # single <c> component node, but with all of this parent nodes still attached. From
+  # there we can determine all of its parent <c> nodes so that we can correctly
+  # reconstruct its placement within the original ead hierarchy.
+  #
+  # The solr fields returned by this method are:
+  #
+  # id:: Unique identifier using the id attribute and the <eadid>
+  # eadid_s:: The <eadid> node of the ead. This is so we know which ead this component belongs to.
+  # parent_id_s:: The id attribute of the parent <c> node
+  # parent_ids_display:: Stored as a display fields so it is not indexed. See parent_id_list for more info.
+  # parent_unittitles_display:: Stored as a display fields so it is not indexed. See parent_id_list for more info.
+  # component_level_i:: numeric level of the component
+  # component_children_b:: Boolean field indicating whether or not the component has any child <c> nodes attached to it
+  #
+  # These fields are used so that we may reconstruct placement of a single component
+  # within the hierarchy of the original ead.
+  def additional_component_fields(node, addl_fields = Hash.new)
+    addl_fields["id"]                        = [node.xpath("//eadid").text, node.attr("id")].join(":")
+    addl_fields["eadid_s"]                   = node.xpath("//eadid").text
+    addl_fields["parent_id_s"]               = node.parent.attr("id") unless node.parent.attr("id").nil?
+    addl_fields["parent_ids_display"]        = parent_id_list(node)
+    addl_fields["parent_unittitles_display"] = parent_unittitle_list(node)
+    addl_fields["component_level_i"]         = parent_id_list(node).length + 1
+    addl_fields["component_children_b"]      = component_children?(node)
+    return addl_fields
+  end
+
+  # Array of all id attributes from the component's parent <c> nodes, sorted in descending order
+  # This is used to reconstruct the order of component documents that should appear above
+  # a specific item-level component.
+  def parent_id_list(node, results = Array.new)
+    while node.parent.name == "c"
+      parent = node.parent
+      results << parent.attr("id") unless parent.attr("id").nil?
+      node = parent
+    end
+    return results.reverse
+  end
+
+  # Array of all unittitle nodes from the component's parent <c> nodes, sort in descending order
+  # This is useful if you want to display a list of a component's parent containers in
+  # the correct order, ex:
+  #   ["Series I", "Subseries a", "Sub-subseries 1"]
+  # From there, you can assemble and display as you like.
+  def parent_unittitle_list(node, results = Array.new)
+    while node.parent.name == "c"
+      parent = node.parent
+      part = Nokogiri::XML(parent.to_xml)
+      results << get_title(part)
+      node = parent
+    end
+    return results.reverse
+  end
+
+  def get_title(xml)
+    title = xml.at("/c/did/unittitle")
+    date  = xml.at("/c/did/unitdate")
+    if !title.nil? and !title.content.empty?
+      return ead_clean_xml(title.content)
+    elsif !date.nil? and !date.content.empty?
+      return ead_clean_xml(date.content)
+    else
+      return "[No title available]"
+    end
+  end
+
+  # Converts formatting elements in the ead into html tags
+  def ead_clean_xml(string)
+    string.gsub!(/<title/,"<span")
+    string.gsub!(/<\/title/,"</span")
+    string.gsub!(/render=/,"class=")
+    sanitize = Sanitize.clean(string, :elements => ['span'], :attributes => {'span' => ['class']})
+    sanitize.gsub("\n",'').gsub(/\s+/, ' ').strip
+  end
+
+  # Returns true or false for a component with attached <c> child nodes.
+  def component_children?(node, t = Array.new)
+    node.children.each { |n| t << n.name }
+    t.include?("c") ? TRUE : FALSE
+  end
+
+end

data/lib/solr_ead/component.rb

@@ -0,0 +1,74 @@
+class SolrEad::Component
+
+  include OM::XML::Document
+  include Solrizer::XML::TerminologyBasedSolrizer
+
+  # Define each term in your ead that you want put into the solr document
+  set_terminology do |t|
+    t.root(:path=>"c", :index_as => [:not_searchable, :not_displayable])
+    t.ref(:path=>"/c/@id")
+    t.level(:path=>"/c/@level", :index_as => [:facetable])
+
+    t.title(:path=>"unittitle", :attributes=>{ :type => :none }, :index_as=>[:searchable, :displayable])
+
+    # Default facets
+    t.corpname(:index_as=>[:facetable])
+    t.famname(:index_as=>[:facetable])
+    t.genreform(:index_as=>[:facetable])
+    t.geogname(:index_as=>[:facetable])
+    t.name(:index_as=>[:facetable])
+    t.persname(:index_as=>[:facetable])
+    t.subject(:index_as=>[:facetable])
+
+    # Archival material
+    t.container(:attributes=>{ :type => "Box" }, :index_as => [:not_searchable, :not_displayable]) {
+      t.label(:path=>{ :attribute=>"label" }, :index_as => [:facetable])
+    }
+    t.material(:proxy=>[:container, :label])
+
+    # These terms are proxied to match with Blacklight's default facets, but otherwise
+    # you can remove them or rename the above facet terms to match with your solr
+    # implementation.
+    t.subject_geo(:proxy=>[:geogname])
+    t.subject_topic(:proxy=>[:subject])
+
+    t.accessrestrict(:path=>"accessrestrict/p")
+    t.accessrestrict_heading(:path=>"accessrestrict/head", :index_as=>[:not_searchable, :displayable])
+    t.accruals(:path=>"accruals/p")
+    t.accruals_heading(:path=>"accruals/head", :index_as=>[:not_searchable, :displayable])
+    t.acqinfo(:path=>"acqinfo/p")
+    t.acqinfo_heading(:path=>"acqinfo/head", :index_as=>[:not_searchable, :displayable])
+    t.altformavail(:path=>"altformavail/p")
+    t.altformavail_heading(:path=>"altformavail/head", :index_as=>[:not_searchable, :displayable])
+    t.appraisal(:path=>"appraisal/p")
+    t.appraisal_heading(:path=>"appraisal/head", :index_as=>[:not_searchable, :displayable])
+    t.arrangement(:path=>"arrangement/p")
+    t.arrangement_heading(:path=>"arrangement/head", :index_as=>[:not_searchable, :displayable])
+    t.custodhist(:path=>"custodhist/p")
+    t.custodhist_heading(:path=>"custodhist/head", :index_as=>[:not_searchable, :displayable])
+    t.fileplan(:path=>"fileplan/p")
+    t.fileplan_heading(:path=>"fileplan/head", :index_as=>[:not_searchable, :displayable])
+    t.originalsloc(:path=>"originalsloc/p")
+    t.originalsloc_heading(:path=>"originalsloc/head", :index_as=>[:not_searchable, :displayable])
+    t.phystech(:path=>"phystech/p")
+    t.phystech_heading(:path=>"phystech/head", :index_as=>[:not_searchable, :displayable])
+    t.processinfo(:path=>"processinfo/p")
+    t.processinfo_heading(:path=>"processinfo/head", :index_as=>[:not_searchable, :displayable])
+    t.relatedmaterial(:path=>"relatedmaterial/p")
+    t.relatedmaterial_heading(:path=>"relatedmaterial/head", :index_as=>[:not_searchable, :displayable])
+    t.separatedmaterial(:path=>"separatedmaterial/p")
+    t.separatedmaterial_heading(:path=>"separatedmaterial/head", :index_as=>[:not_searchable, :displayable])
+    t.scopecontent(:path=>"scopecontent/p")
+    t.scopecontent_heading(:path=>"scopecontent/head", :index_as=>[:not_searchable, :displayable])
+    t.userestrict(:path=>"userestrict/p")
+    t.userestrict_heading(:path=>"userestrict/head", :index_as=>[:not_searchable, :displayable])
+
+  end
+
+  def to_solr(solr_doc = Hash.new)
+    super(solr_doc)
+    solr_doc.merge!({"format"          => "Archival Item"})
+    solr_doc.merge!({"heading_display" => [ solr_doc["parent_unittitle_list_t"], self.title.first ].join(" >> ")  })
+  end
+
+end

data/lib/solr_ead/document.rb

@@ -0,0 +1,72 @@
+class SolrEad::Document
+
+  include OM::XML::Document
+  include Solrizer::XML::TerminologyBasedSolrizer
+  include SolrEad::OmBehaviors
+
+  # Define each term in your ead that you want put into the solr document
+  set_terminology do |t|
+    t.root(:path=>"ead", :index_as => [:not_searchable])
+
+    t.eadid
+    t.corpname(:index_as=>[:facetable])
+    t.famname(:index_as=>[:facetable])
+    t.genreform(:index_as=>[:facetable])
+    t.geogname(:index_as=>[:facetable])
+    t.name(:index_as=>[:facetable])
+    t.persname(:index_as=>[:facetable])
+    t.subject(:index_as=>[:facetable])
+
+    # These terms are proxied to match with Blacklight's default facets, but otherwise
+    # you can remove them or rename the above facet terms to match with your solr
+    # implementation.
+    t.subject_geo(:proxy=>[:geogname])
+    t.subject_topic(:proxy=>[:subject])
+
+    t.title(:path=>"titleproper", :attributes=>{ :type => :none }, :index_as=>[:searchable, :displayable])
+    t.title_filing(:path=>"titleproper", :attributes=>{ :type => "filing" }, :index_as=>[:not_searchable, :sortable])
+
+    # General field available within archdesc
+    t.accessrestrict(:path=>"archdesc/accessrestrict/p")
+    t.accessrestrict_heading(:path=>"archdesc/accessrestrict/head", :index_as=>[:not_searchable, :displayable])
+    t.accruals(:path=>"archdesc/accruals/p")
+    t.accruals_heading(:path=>"archdesc/accruals/head", :index_as=>[:not_searchable, :displayable])
+    t.acqinfo(:path=>"archdesc/acqinfo/p")
+    t.acqinfo_heading(:path=>"archdesc/acqinfo/head", :index_as=>[:not_searchable, :displayable])
+    t.altformavail(:path=>"archdesc/altformavail/p")
+    t.altformavail_heading(:path=>"archdesc/altformavail/head", :index_as=>[:not_searchable, :displayable])
+    t.appraisal(:path=>"archdesc/appraisal/p")
+    t.appraisal_heading(:path=>"archdesc/appraisal/head", :index_as=>[:not_searchable, :displayable])
+    t.arrangement(:path=>"archdesc/arrangement/p")
+    t.arrangement_heading(:path=>"archdesc/arrangement/head", :index_as=>[:not_searchable, :displayable])
+    t.custodhist(:path=>"archdesc/custodhist/p")
+    t.custodhist_heading(:path=>"archdesc/custodhist/head", :index_as=>[:not_searchable, :displayable])
+    t.fileplan(:path=>"archdesc/fileplan/p")
+    t.fileplan_heading(:path=>"archdesc/fileplan/head", :index_as=>[:not_searchable, :displayable])
+    t.originalsloc(:path=>"archdesc/originalsloc/p")
+    t.originalsloc_heading(:path=>"archdesc/originalsloc/head", :index_as=>[:not_searchable, :displayable])
+    t.phystech(:path=>"archdesc/phystech/p")
+    t.phystech_heading(:path=>"archdesc/phystech/head", :index_as=>[:not_searchable, :displayable])
+    t.processinfo(:path=>"archdesc/processinfo/p")
+    t.processinfo_heading(:path=>"archdesc/processinfo/head", :index_as=>[:not_searchable, :displayable])
+    t.relatedmaterial(:path=>"archdesc/relatedmaterial/p")
+    t.relatedmaterial_heading(:path=>"archdesc/relatedmaterial/head", :index_as=>[:not_searchable, :displayable])
+    t.separatedmaterial(:path=>"archdesc/separatedmaterial/p")
+    t.separatedmaterial_heading(:path=>"archdesc/separatedmaterial/head", :index_as=>[:not_searchable, :displayable])
+    t.scopecontent(:path=>"archdesc/scopecontent/p")
+    t.scopecontent_heading(:path=>"archdesc/scopecontent/head", :index_as=>[:not_searchable, :displayable])
+    t.userestrict(:path=>"archdesc/userestrict/p")
+    t.userestrict_heading(:path=>"archdesc/userestrict/head", :index_as=>[:not_searchable, :displayable])
+
+  end
+
+  def to_solr(solr_doc = Hash.new)
+    super(solr_doc)
+    solr_doc.merge!({"id"              => self.eadid.first})
+    solr_doc.merge!({"eadid_s"         => self.eadid.first})
+    solr_doc.merge!({"format"          => "Archival Collection"})
+    solr_doc.merge!({"heading_display" => ("Guide to the " + self.title.first)})
+    return solr_doc
+  end
+
+end