active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/scoped_query_spec.rb

@@ -1,97 +1,107 @@
 require 'spec_helper'
 
-describe 'scoped queries' do
-
-  before(:each) do
+describe "scoped queries" do
+  
+  before(:each) do 
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
-        has_metadata :name => 'properties', :type => ActiveFedora::SimpleDatastream do |m|
-          m.field 'foo', :string
-          m.field 'bar', :string
-          m.field 'baz', :string
+        has_metadata "properties", type: ActiveFedora::SimpleDatastream do |m|
+          m.field "foo", :string
+          m.field "bar", :string
+          m.field "baz", :string
         end
 
-        delegate_to :properties, [:foo, :bar, :baz], multiple: true
+        has_attributes :foo, :bar, :baz, datastream: 'properties', multiple: true
 
         def to_solr(doc = {})
           doc = super
           doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
           doc
         end
-
+      
       end
     end
 
   end
-
+  
   after(:each) do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
 
 
-  describe 'When there is one object in the store' do
+  describe "When there is one object in the store" do
     let!(:test_instance) { ModelIntegrationSpec::Basic.create!()}
 
     after do
       test_instance.delete
     end
-
-    describe '.all' do
-      it 'should return an array of instances of the calling Class' do
-        result = ModelIntegrationSpec::Basic.all
-        expect(result).to be_instance_of(Array)
+    
+    describe ".all" do
+      it "should return an array of instances of the calling Class" do
+        result = ModelIntegrationSpec::Basic.all.to_a
+        result.should be_instance_of(Array)
         # this test is meaningless if the array length is zero
-        expect(result.length).to be > 0
+        result.length.should > 0
         result.each do |obj|
-          expect(obj.class).to eq(ModelIntegrationSpec::Basic)
+          obj.class.should == ModelIntegrationSpec::Basic
         end
       end
     end
 
-    describe '.first' do
-      it 'should return one instance of the calling class' do
-        expect(ModelIntegrationSpec::Basic.first).to eq(test_instance)
+    describe ".first" do
+      it "should return one instance of the calling class" do
+        ModelIntegrationSpec::Basic.first.should == test_instance
       end
     end
   end
 
-  describe 'with multiple objects' do
-    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(:foo => 'Beta', :bar => 'Chips')}
-    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(:foo => 'Alpha', :bar => 'Peanuts')}
-    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(:foo => 'Sigma', :bar => 'Peanuts')}
+  describe "with multiple objects" do
+    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(:foo=>'Beta', :bar=>'Chips')}
+    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(:foo=>'Alpha', :bar=>'Peanuts')}
+    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(:foo=>'Sigma', :bar=>'Peanuts')}
 
-    after do
-      test_instance1.delete
-      test_instance2.delete
-      test_instance3.delete
-    end
-    it 'should query' do
-      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string) => 'Beta')).to eq([test_instance1])
-      expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq([test_instance1])
-    end
-    it 'should order' do
-      expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq([test_instance2, test_instance1, test_instance3])
-    end
-    it 'should limit' do
-      expect(ModelIntegrationSpec::Basic.limit(1)).to eq([test_instance1])
-    end
+    describe "when the objects are in fedora" do
+      after do
+        test_instance1.delete
+        test_instance2.delete
+        test_instance3.delete
+      end
+      it "should query" do
+        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string)=> 'Beta').should == [test_instance1]
+        ModelIntegrationSpec::Basic.where('foo' => 'Beta').should == [test_instance1]
+      end
+      it "should order" do
+        ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').should == [test_instance2, test_instance1, test_instance3]
+      end
+      it "should limit" do
+        ModelIntegrationSpec::Basic.limit(1).should == [test_instance1]
+      end
 
-    it 'should chain queries' do
-      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq([test_instance2])
-    end
+      it "should chain queries" do
+        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1).should == [test_instance2]
+      end
 
-    it 'should chain count' do
-      expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq(2)
+      it "should chain count" do
+        ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count.should == 2 
+      end
     end
 
     describe "when one of the objects in solr isn't in fedora" do
-      it 'should log an error' do
-        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance1.pid, nil).and_call_original
-        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance2.pid, nil).and_raise(ActiveFedora::ObjectNotFoundError)
-        expect(ModelIntegrationSpec::Basic).to receive(:find_one).with(test_instance3.pid, nil).and_call_original
-        expect(ActiveFedora::Relation.logger).to receive(:error).with("When trying to find_each #{test_instance2.pid}, encountered an ObjectNotFoundError. Solr may be out of sync with Fedora")
-        expect(ModelIntegrationSpec::Basic.all).to eq([test_instance1, test_instance3])
+      let!(:pid) { test_instance2.pid }
+      before { test_instance2.inner_object.delete }
+      after do
+        ActiveFedora::SolrService.instance.conn.tap do |conn|
+          conn.delete_by_query "id:\"#{pid}\""
+          conn.commit
+        end
+        test_instance1.delete
+        test_instance3.delete
+      end
+      it "should log an error" do
+        ActiveFedora::Relation.logger.should_receive(:error).with("Although #{pid} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
+        ModelIntegrationSpec::Basic.all.should == [test_instance1, test_instance3]
       end
     end
   end
 end
+

data/spec/integration/solr_instance_loader_spec.rb

@@ -11,7 +11,7 @@ describe ActiveFedora::SolrInstanceLoader do
   let(:context) { ActiveFedora::Base }
   let(:pid) { nil }
   let(:solr_doc) { nil }
-  let(:active_fedora_object) { ActiveFedora::Base.find(pid, :cast => true) }
+  let(:active_fedora_object) { ActiveFedora::Base.find(pid) }
   subject { ActiveFedora::SolrInstanceLoader.new(context, pid, solr_doc) }
 
   describe 'existing pid' do
@@ -22,14 +22,14 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
       it 'it casts the SOLR document and casts into an AF::Base object' do
         expect(subject.object).to eq(active_fedora_object)
       end
     end
     describe 'with a mismatching solr document' do
       let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => mismatching_pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject
@@ -47,7 +47,7 @@ describe ActiveFedora::SolrInstanceLoader do
       end
     end
     describe 'with matching solr document' do
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject.object
@@ -56,7 +56,7 @@ describe ActiveFedora::SolrInstanceLoader do
     end
     describe 'with a mismatching solr document' do
       let(:mismatching_pid) { @test_object2.pid }
-      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id => mismatching_pid).first }
+      let(:solr_doc) { ActiveFedora::Base.find_with_conditions(:id=>mismatching_pid).first }
       it 'it raise ObjectNotFoundError' do
         expect {
           subject

data/spec/integration/solr_service_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 require 'active_fedora'
 
 describe ActiveFedora::SolrService do
-  describe '#reify_solr_results' do
+  describe "#reify_solr_results" do
     before(:all) do
       class FooObject < ActiveFedora::Base
         def self.pid_namespace
-          'foo'
+          "foo"
         end
-
-        has_metadata :name => 'descMetadata', :type => ActiveFedora::QualifiedDublinCoreDatastream
+  
+        has_metadata :name => "descMetadata", :type => ActiveFedora::QualifiedDublinCoreDatastream
       end
       @test_object = ActiveFedora::Base.new
       @test_object.label = 'test_object'
       @foo_object = FooObject.new
       @foo_object.label = 'foo_object'
-      attributes = {'language' => {0 => 'Italian'},
-                    'creator' => {0 => 'Linguist, A.'},
-                    'geography' => {0 => 'Italy'},
-                    'title' => {0 => 'Italian and Spanish: A Comparison of Common Phrases'}}
+      attributes = {"language"=>{0=>"Italian"},
+                    "creator"=>{0=>"Linguist, A."},
+                    "geography"=>{0=>"Italy"},
+                    "title"=>{0=>"Italian and Spanish: A Comparison of Common Phrases"}}
       @foo_object.descMetadata.update_indexed_attributes(attributes)
       @test_object.save
       @foo_object.save
@@ -35,78 +35,78 @@ describe ActiveFedora::SolrService do
       @foo_object.delete
       Object.send(:remove_const, :FooObject)
     end
-    it 'should return an array of objects that are of the class stored in active_fedora_model_s' do
+    it "should return an array of objects that are of the class stored in active_fedora_model_s" do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
       result = ActiveFedora::SolrService.reify_solr_results(solr_result)
-      expect(result.length).to eq(2)
+      result.length.should == 2
       result.each do |r|
-        expect(r.class == ActiveFedora::Base || r.class == FooObject).to be_truthy
+        (r.class == ActiveFedora::Base || r.class == FooObject).should be_true
       end
     end
-
+    
     it 'should load objects from solr data if a :load_from_solr option is passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
-      expect(result.length).to eq(2)
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+      result.length.should == 2
       result.each do |r|
-        expect(r.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
-        expect([ActiveFedora::Base, FooObject]).to include(r.class)
-        expect(['test_object', 'foo_object']).to include(r.label)
-        expect(@test_object.inner_object.profile).to eq(@profiles['test'])
-        expect(@foo_object.inner_object.profile).to eq(@profiles['foo'])
-        expect(@foo_object.datastreams['descMetadata'].profile).to eq(@profiles['foo_descMetadata'])
-        expect(@foo_object.datastreams['descMetadata'].content).to be_equivalent_to(@foo_content)
+        r.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
+        [ActiveFedora::Base, FooObject].should include(r.class)
+        ['test_object','foo_object'].should include(r.label)
+        @test_object.inner_object.profile.should == @profiles['test']
+        @foo_object.inner_object.profile.should == @profiles['foo']
+        @foo_object.datastreams['descMetadata'].profile.should == @profiles['foo_descMetadata']
+        @foo_object.datastreams['descMetadata'].content.should be_equivalent_to(@foo_content)
       end
     end
-
+    
     it 'should instantiate all datastreams in the solr doc, even ones undeclared by the class' do
-      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid
-      expect(obj.datastreams.keys).to include('descMetadata')
+      obj = ActiveFedora::Base.load_instance_from_solr @foo_object.pid 
+      obj.datastreams.keys.should include('descMetadata')
     end
-
+    
     it 'should #reify a lightweight object as a new instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
       real_foo = solr_foo.reify
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
-      expect(real_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
-      expect(solr_foo.label).to eq('foo_object')
-      expect(real_foo.label).to eq('foo_object')
+      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
+      real_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
+      solr_foo.label.should == 'foo_object'
+      real_foo.label.should == 'foo_object'
     end
-
+    
     it 'should #reify! a lightweight object within the same instance' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::SolrDigitalObject)
+      solr_foo.inner_object.should be_a(ActiveFedora::SolrDigitalObject)
       solr_foo.reify!
-      expect(solr_foo.inner_object).to be_a(ActiveFedora::DigitalObject)
-      expect(solr_foo.label).to eq('foo_object')
+      solr_foo.inner_object.should be_a(ActiveFedora::DigitalObject)
+      solr_foo.label.should == 'foo_object'
     end
-
+    
     it 'should raise an exception when attempting to reify a first-class object' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
       solr_foo = result.first
-      expect {solr_foo.reify}.not_to raise_exception
-      expect {solr_foo.reify!}.not_to raise_exception
-      expect {solr_foo.reify!}.to raise_exception(/already a full/)
-      expect {solr_foo.reify}.to raise_exception(/already a full/)
+      lambda {solr_foo.reify}.should_not raise_exception
+      lambda {solr_foo.reify!}.should_not raise_exception
+      lambda {solr_foo.reify!}.should raise_exception(/already a full/)
+      lambda {solr_foo.reify}.should raise_exception(/already a full/)
     end
-
+  
     it 'should call load_instance_from_solr if :load_from_solr option passed in' do
       query = "id\:#{ActiveFedora::SolrService.escape_uri_for_query(@test_object.pid)} OR id\:#{ActiveFedora::SolrService.escape_uri_for_query(@foo_object.pid)}"
       solr_result = ActiveFedora::SolrService.query(query)
-      expect(ActiveFedora::Base).to receive(:load_instance_from_solr).once
-      expect(FooObject).to receive(:load_instance_from_solr).once
-      result = ActiveFedora::SolrService.reify_solr_results(solr_result, {:load_from_solr => true})
+      ActiveFedora::Base.should_receive(:load_instance_from_solr).once
+      FooObject.should_receive(:load_instance_from_solr).once
+      result = ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
     end
-
+    
   end
 end

data/spec/samples/hydra-mods_article_datastream.rb

@@ -1,6 +1,6 @@
-require 'active-fedora'
+require "active-fedora"
 module Hydra
-
+  
   # This is an example of a OmDatastream that defines an OM terminology for MODS xml
   # It focuses on the aspects of MODS that deal with descriptive metadata for published articles
   # This is not the hydra-head plugin version of this OM Terminology; See https://github.com/projecthydra/hydra-head/blob/master/lib/hydra/mods_article.rb
@@ -11,135 +11,135 @@ module Hydra
   # * 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
+  # * 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::OmDatastream
+  class ModsArticleDatastream < ActiveFedora::OmDatastream       
 
     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.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.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.lang_code(:index_as=>[:facetable], :path=>"languageTerm", :attributes=>{:type=>"code"})
       }
-      t.abstract
+      t.abstract   
       t.subject {
-        t.topic(:index_as => [:facetable])
-      }
-      t.topic_tag(:proxy => [:subject, :topic])
+        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_(:index_as => [:searchable]) {
+      t.name_(:index_as=>[:searchable]) {
         # this is a namepart
-        t.namePart(:type => :string, :label => 'generic name')
+        t.namePart(:type=>:string, :label=>"generic name")
         # affiliations are great
         t.affiliation
-        t.institution(:path => 'affiliation', :index_as => [:facetable], :label => 'organization')
+        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.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, :stored_searchable])
-      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(:index_as => [:stored_searchable]) {
-        t.text(:path => 'roleTerm', :attributes => {:type => 'text'}, :index_as => [:stored_searchable])
-        t.code(:path => 'roleTerm', :attributes => {:type => 'code'})
+      # lookup :person, :first_name        
+      t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable, :stored_searchable])
+      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(:index_as=>[:stored_searchable]) {
+        t.text(:path=>"roleTerm",:attributes=>{:type=>"text"}, :index_as=>[:stored_searchable])
+        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.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.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.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.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', :type => :date, :index_as => [:stored_searchable])
+          t.start_page(:proxy=>[:pages, :start])
+          t.end_page(:proxy=>[:pages, :end])
+          t.publication_date(:path=>"date", :type=>:date, :index_as=>[:stored_searchable])
         }
       }
       t.note
-      t.location(:path => 'location') {
-        t.url(:path => 'url')
+      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 => [:title_info, :main_title])
-      t.journal_title(:proxy => [:journal, :title_info, :main_title])
+      t.publication_url(:proxy=>[:location,:url])
+      t.peer_reviewed(:proxy=>[:journal,:origin_info,:issuance], :index_as=>[:facetable])
+      t.title(:proxy=>[: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.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.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.roleTerm("Author", :authority=>"marcrelator", :type=>"text")
                }
              }
              xml.typeOfResource
-             xml.genre(:authority => 'marcgt')
+             xml.genre(:authority=>"marcgt")
              xml.language {
-               xml.languageTerm(:authority => 'iso639-2b', :type => 'code')
+               xml.languageTerm(:authority=>"iso639-2b", :type=>"code")
              }
              xml.abstract
              xml.subject {
                xml.topic
              }
-             xml.relatedItem(:type => 'host') {
+             xml.relatedItem(:type=>"host") {
                xml.titleInfo {
                  xml.title
                }
-               xml.identifier(:type => 'issn')
+               xml.identifier(:type=>"issn")
                xml.originInfo {
                  xml.publisher
                  xml.dateIssued
                  xml.issuance
                }
                xml.part {
-                 xml.detail(:type => 'volume') {
+                 xml.detail(:type=>"volume") {
                    xml.number
                  }
-                 xml.detail(:type => 'number') {
+                 xml.detail(:type=>"number") {
                    xml.number
                  }
-                 xml.extent(:unit => 'pages') {
+                 xml.extent(:unit=>"pages") {
                    xml.start
                    xml.end
                  }
@@ -153,18 +153,18 @@ module Hydra
       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.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')
+            xml.roleTerm("Author", :type=>"text")
           }
         }
       end
@@ -173,7 +173,7 @@ module Hydra
 
     def self.full_name_template
       builder = Nokogiri::XML::Builder.new do |xml|
-        xml.full_name(:type => 'personal')
+        xml.full_name(:type => "personal")
       end
       return builder.doc.root
     end
@@ -182,33 +182,33 @@ module Hydra
     # Uses mods:name[@type="corporate"]
     def self.organization_template
       builder = Nokogiri::XML::Builder.new do |xml|
-        xml.name(:type => 'corporate') {
+        xml.name(:type=>"corporate") {
           xml.namePart
           xml.role {
-            xml.roleTerm(:authority => 'marcrelator', :type => 'text')
-          }
+            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.name(:type=>"conference") {
           xml.namePart
           xml.role {
-            xml.roleTerm(:authority => 'marcrelator', :type => 'text')
-          }
+            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
+    def insert_contributor(type, opts={})
+      case type.to_sym 
       when :person
         node = Hydra::ModsArticleDatastream.person_template
         nodeset = self.find_by_terms(:person)
@@ -223,7 +223,7 @@ module Hydra
         node = nil
         index = nil
       end
-
+      
       unless nodeset.nil?
         if nodeset.empty?
           self.ng_xml.root.add_child(node)
@@ -234,282 +234,282 @@ module Hydra
         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'
+       {"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'
+      {"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'
+        "hst" => "Host"
       }
     end
-
+    
     def self.organization_relator_terms
       {
-        'fnd' => 'Funder',
-        'hst' => 'Host'
+        "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'}
+       {"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']
+        ["data", "supporting file", "profile", "lorem ipsum", "dolor"]
       end
 
-    def to_solr(solr_doc = {})
+    def to_solr(solr_doc=Hash.new)
       super(solr_doc)
-
-      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('object_type', :facetable), 'Article')
-      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('mods_journal_title_info', :facetable), 'Unknown') if solr_doc['mods_journal_title_info_facet'].nil?
+            
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('object_type', :facetable), "Article")
+      ::Solrizer::Extractor.insert_solr_field_value(solr_doc, Solrizer.default_field_mapper.solr_name('mods_journal_title_info', :facetable), "Unknown") if solr_doc["mods_journal_title_info_facet"].nil? 
 
       solr_doc
     end