stanford-mods 0.0.13 → 0.0.14

data/.travis.yml

@@ -7,4 +7,6 @@ rvm:
 notifications:
   email:
     - ndushay@stanford.edu
-		- jdeering@stanford.edu
+    - jdeering@stanford.edu
+before_install:
+  gem update --system 1.8.24

data/lib/stanford-mods/searchworks.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 require 'stanford-mods/searchworks_languages'
-
+require 'logger'
 # SearchWorks specific wranglings of MODS metadata as a mixin to the Stanford::Mods::Record object
 module Stanford
   module Mods
@@ -182,6 +182,437 @@ module Stanford
         result
       end
             
+      # Values are the contents of:
+      #   mods/genre
+      #   mods/subject/topic
+      # @return [Array<String>] values for the topic_search Solr field for this document or nil if none
+      def topic_search
+        @topic_search ||= begin
+          vals = self.term_values(:genre) || []
+          vals.concat(subject_topics) if subject_topics
+          vals.empty? ? nil : vals
+        end
+      end
+      def place
+        vals = self.term_values([:origin_info,:place,:placeTerm])
+        vals
+      end
+      def main_author_w_date_test
+        result = nil
+        first_wo_role = nil
+        self.plain_name.each { |n|
+          if n.role.size == 0
+            first_wo_role ||= n
+          end
+          n.role.each { |r|
+            if r.authority.include?('marcrelator') && 
+              (r.value.include?('Creator') || r.value.include?('Author'))
+              result ||= n.display_value_w_date
+            end          
+          }
+        }
+        if !result && first_wo_role
+          result = first_wo_role.display_value_w_date
+        end
+        result
+      end
+      #remove trailing commas
+      def sw_full_title_without_commas
+        toret = self.sw_full_title
+        if toret
+          toret = toret.gsub(/,$/, '')
+        end
+        toret
+      end
+
+      def sw_logger
+        @logger ||= Logger.new(STDOUT)
+      end
+      # Values are the contents of:
+      #   subject/geographic
+      #   subject/hierarchicalGeographic
+      #   subject/geographicCode  (only include the translated value if it isn't already present from other mods geo fields)
+      # @return [Array<String>] values for the geographic_search Solr field for this document or nil if none
+      def geographic_search
+        @geographic_search ||= begin
+          result = self.sw_geographic_search
+
+          # TODO:  this should go into stanford-mods ... but then we have to set that gem up with a Logger
+          # print a message for any unrecognized encodings
+          xvals = self.subject.geographicCode.translated_value
+          codes = self.term_values([:subject, :geographicCode]) 
+          if codes && codes.size > xvals.size
+            self.subject.geographicCode.each { |n|
+              if n.authority != 'marcgac' && n.authority != 'marccountry'
+                sw_logger.info("#{druid} has subject geographicCode element with untranslated encoding (#{n.authority}): #{n.to_xml}")
+              end
+            }
+          end
+
+          # FIXME:  stanford-mods should be returning [], not nil ... 
+          return nil if !result || result.empty?
+          result
+        end
+      end
+
+      # Values are the contents of:
+      #   subject/name
+      #   subject/occupation  - no subelements
+      #   subject/titleInfo
+      # @return [Array<String>] values for the subject_other_search Solr field for this document or nil if none
+      def subject_other_search
+        @subject_other_search ||= begin
+          vals = subject_occupations ? Array.new(subject_occupations) : []
+          vals.concat(subject_names) if subject_names
+          vals.concat(subject_titles) if subject_titles
+          vals.empty? ? nil : vals
+        end
+      end
+
+      # Values are the contents of:
+      #   subject/temporal
+      #   subject/genre
+      # @return [Array<String>] values for the subject_other_subvy_search Solr field for this document or nil if none
+      def subject_other_subvy_search
+        @subject_other_subvy_search ||= begin
+          vals = subject_temporal ? Array.new(subject_temporal) : []
+          gvals = self.term_values([:subject, :genre])
+          vals.concat(gvals) if gvals
+
+          # print a message for any temporal encodings
+          self.subject.temporal.each { |n| 
+            sw_logger.info("#{druid} has subject temporal element with untranslated encoding: #{n.to_xml}") if !n.encoding.empty?
+          }
+
+          vals.empty? ? nil : vals
+        end
+      end
+      # @return [Array<String>] values for the pub_date_group_facet
+      def pub_date_groups year
+        if not year
+          return nil
+        end
+        year=year.to_i
+        current_year=Time.new.year.to_i
+        result = []
+        if year >= current_year - 1
+          result << "This year"
+        else
+          if year >= current_year - 3
+            result << "Last 3 years"
+          else
+            if year >= current_year - 10
+              result << "Last 10 years"
+            else
+              if year >= current_year - 50
+                result << "Last 50 years"
+              else
+                result << "More than 50 years ago"
+              end
+            end
+          end
+        end
+      end
+
+      # select one or more format values from the controlled vocabulary here:
+      #   http://searchworks-solr-lb.stanford.edu:8983/solr/select?facet.field=format&rows=0&facet.sort=index
+      # based on the dor_content_type
+      # @return [String] value in the SearchWorks controlled vocabulary
+      def format
+        val=[]
+        formats=self.term_values(:typeOfResource)
+        if formats
+          formats.each do |form|
+            case form
+            when 'still image'
+              val << 'Image'
+            when 'mixed material'
+              val << 'Manuscript/Archive'
+            when 'moving image'
+              val << 'Video'
+            when 'three dimensional object'
+              val <<'Other'
+            when 'cartographic'
+              val << 'Map/Globe'
+            when 'sound recording-musical'
+              val << 'Music-Recording'
+            when 'sound recording-nonmusical'
+              val << 'Sound Recording'
+            when 'software, multimedia'
+              val << 'Computer File'      
+            else
+              sw_logger.warn "#{druid} has an unknown typeOfResource #{form}"
+            end
+          end
+        end
+        if val.length>0
+          return val.uniq
+        end
+        if not self.typeOfResource or self.typeOfResource.length == 0
+          sw_logger.warn "#{druid} has no valid typeOfResource"
+          []
+        end
+      end
+
+      # Values are the contents of:
+      #  all subject subelements except subject/cartographic plus  genre top level element
+      # @return [Array<String>] values for the subject_all_search Solr field for this document or nil if none
+      def subject_all_search
+        vals = topic_search ? Array.new(topic_search) : []
+        vals.concat(geographic_search) if geographic_search
+        vals.concat(subject_other_search) if subject_other_search
+        vals.concat(subject_other_subvy_search) if subject_other_subvy_search
+        vals.empty? ? nil : vals
+      end
+      def pub_date_display
+        if pub_dates
+          pub_dates.first
+        else
+          nil
+        end
+      end
+      #get the dates from dateIssued, and dateCreated merged into 1 array.
+      # @return [Array<String>] values for the issue_date_display Solr field for this document or nil if none
+      def pub_dates
+        vals = self.term_values([:origin_info,:dateIssued])
+        if vals
+          vals = vals.concat self.term_values([:origin_info,:dateCreated]) unless not self.term_values([:origin_info,:dateCreated])
+        else
+          vals = self.term_values([:origin_info,:dateCreated])
+        end
+        vals and vals.empty? ? nil : vals
+      end
+      def is_number?(object)
+        true if Integer(object) rescue false
+      end
+      def is_date?(object)
+        true if Date.parse(object) rescue false
+      end
+  
+      # Get the publish year from mods
+      #@return [String] 4 character year or nil if no valid date was found
+      def pub_year
+        #use the cached year if there is one
+        if @pub_year
+          if @pub_year == ''
+            return nil
+          end
+          return @pub_year
+        end
+        dates=pub_dates
+        if dates
+          year=[]
+          pruned_dates=[]
+          dates.each do |f_date|
+            #remove ? and [] 
+            pruned_dates << f_date.gsub('?','').gsub('[','').gsub(']','')
+          end
+          #try to find a date starting with the most normal date formats and progressing to more wonky ones
+          @pub_year=get_plain_four_digit_year pruned_dates
+          return @pub_year if @pub_year
+          @pub_year=get_double_digit_century pruned_dates
+          return @pub_year if @pub_year
+          @pub_year=get_three_digit_year pruned_dates
+          return @pub_year if @pub_year
+          @pub_year=get_single_digit_century pruned_dates
+          return @pub_year if @pub_year
+        end
+        @pub_year=''
+        sw_logger.info("#{druid} no valid pub date found in '#{dates.to_s}'")
+        return nil
+      end
+      #creates a date suitable for sorting. Guarnteed to be 4 digits or nil
+      def pub_date_sort
+        pd=nil
+        if pub_date
+          pd=pub_date
+          if pd.length == 3
+            pd='0'+pd
+          end
+          pd=pd.gsub('--','00')
+        end
+        raise "pub_date_sort was about to return a non 4 digit value #{pd}!" if pd and pd.length !=4 
+        pd
+      end
+      #The year the object was published, , filtered based on max_pub_date and min_pub_date from the config file
+      #@return [String] 4 character year or nil
+      def pub_date
+        val=pub_year
+        if val
+          return val
+        end
+        nil
+      end
+      #Values for the pub date facet. This is less strict than the 4 year date requirements for pub_date
+      #@return <Array[String]> with values for the pub date facet
+      def pub_date_facet
+        if pub_date
+          if pub_date.include? '--'
+            cent=pub_date[0,2].to_i
+            cent+=1
+            cent=cent.to_s+'th century'
+            cent
+          else
+            pub_date
+          end
+        else
+          nil
+        end
+      end
+
+      # Values are the contents of:
+      #   subject/topic
+      #   subject/name
+      #   subject/title
+      #   subject/occupation
+      #  with trailing comma, semicolon, and backslash (and any preceding spaces) removed
+      # @return [Array<String>] values for the topic_facet Solr field for this document or nil if none 
+      def topic_facet
+        vals = subject_topics ? Array.new(subject_topics) : []
+        vals.concat(subject_names) if subject_names
+        vals.concat(subject_titles) if subject_titles
+        vals.concat(subject_occupations) if subject_occupations
+        vals.map! { |val| 
+          v = val.sub(/[\\,;]$/, '')
+          v.strip
+        }
+        vals.empty? ? nil : vals
+      end
+
+      # geographic_search values with trailing comma, semicolon, and backslash (and any preceding spaces) removed
+      # @return [Array<String>] values for the geographic_facet Solr field for this document or nil if none 
+      def geographic_facet
+        geographic_search.map { |val| val.sub(/[\\,;]$/, '').strip } unless !geographic_search
+      end
+
+      # subject/temporal values with trailing comma, semicolon, and backslash (and any preceding spaces) removed
+      # @return [Array<String>] values for the era_facet Solr field for this document or nil if none 
+      def era_facet
+        subject_temporal.map { |val| val.sub(/[\\,;]$/, '').strip } unless !subject_temporal
+      end
+      # @return [String] value with the numeric catkey in it, or nil if none exists
+      def catkey
+        catkey=self.term_values([:record_info,:recordIdentifier])
+        if catkey and catkey.length>0
+          return catkey.first.gsub('a','') #need to ensure catkey is numeric only
+        end
+        nil
+      end
+      def druid= new_druid
+        @druid=new_druid
+      end
+      def druid
+        @druid ? @druid : 'Unknown item'
+      end
+
+      # protected ----------------------------------------------------------
+
+      # convenience method for subject/name/namePart values (to avoid parsing the mods for the same thing multiple times)
+      def subject_names
+        @subject_names ||= self.sw_subject_names
+      end
+
+      # convenience method for subject/occupation values (to avoid parsing the mods for the same thing multiple times)
+      def subject_occupations
+        @subject_occupations ||= self.term_values([:subject, :occupation])
+      end
+
+      # convenience method for subject/temporal values (to avoid parsing the mods for the same thing multiple times)
+      def subject_temporal
+        @subject_temporal ||= self.term_values([:subject, :temporal])
+      end
+
+      # convenience method for subject/titleInfo values (to avoid parsing the mods for the same thing multiple times)
+      def subject_titles
+        @subject_titles ||= self.sw_subject_titles
+      end
+
+      # convenience method for subject/topic values (to avoid parsing the mods for the same thing multiple times)
+      def subject_topics
+        @subject_topics ||= self.term_values([:subject, :topic])
+      end
+  
+      #get a 4 digit year like 1865 from the date array
+      def get_plain_four_digit_year dates
+        dates.each do |f_date|
+          matches=f_date.scan(/\d{4}/)
+          if matches.length == 1
+            @pub_year=matches.first 
+            return matches.first
+          else
+            #if there are multiples, check for ones with CE after them
+            matches.each do |match|
+              #look for things like '1865-6 CE'
+              pos = f_date.index(Regexp.new(match+'...CE'))
+              pos = pos ? pos.to_i : 0
+              if f_date.include?(match+' CE') or pos > 0
+                @pub_year=match
+                return match
+              end 
+            end
+          end
+        end
+        return nil
+      end
+  
+      #get a double digit century like '12th century' from the date array
+      def get_double_digit_century dates
+        dates.each do |f_date|
+          matches=f_date.scan(/\d{2}th/)
+          if matches.length == 1
+            @pub_year=((matches.first[0,2].to_i)-1).to_s+'--'
+            return @pub_year
+          end
+          #if there are multiples, check for ones with CE after them
+          if matches.length > 0
+            matches.each do |match|
+              pos = f_date.index(Regexp.new(match+'...CE'))
+              pos = pos ? pos.to_i : f_date.index(Regexp.new(match+' century CE'))
+              pos = pos ? pos.to_i : 0
+              if f_date.include?(match+' CE') or pos > 0
+                @pub_year=((match[0,2].to_i) - 1).to_s+'--'
+                return @pub_year
+              end 
+            end
+          end
+        end
+        return nil
+      end
+  
+      #get a 3 digit year like 965 from the date array
+      def get_three_digit_year dates
+        dates.each do |f_date|
+          matches=f_date.scan(/\d{3}/)
+          if matches.length > 0
+            return matches.first
+          end
+        end
+        return nil
+      end
+  
+      #get a single digit century like '9th century' from the date array
+      def get_single_digit_century dates
+        dates.each do |f_date|
+          matches=f_date.scan(/\d{1}th/)
+          if matches.length == 1
+            @pub_year=((matches.first[0,2].to_i)-1).to_s+'--'
+            return @pub_year
+          end
+          #if there are multiples, check for ones with CE after them
+          if matches.length > 0
+            matches.each do |match|
+              pos = f_date.index(Regexp.new(match+'...CE'))
+              pos = pos ? pos.to_i : f_date.index(Regexp.new(match+' century CE'))
+              pos = pos ? pos.to_i : 0
+              if f_date.include?(match+' CE') or pos > 0
+                @pub_year=((match[0,1].to_i) - 1).to_s+'--'
+                return @pub_year
+              end 
+            end
+          end
+        end 
+        return nil
+      end      
     end # class Record
   end # Module Mods
 end # Module Stanford

data/lib/stanford-mods/version.rb

@@ -1,6 +1,6 @@
 module Stanford
   module Mods
     # this is the Ruby Gem version
-    VERSION = "0.0.13"
+    VERSION = "0.0.14"
   end
 end

data/spec/searchworks_gdor_spec.rb

@@ -0,0 +1,634 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe "Searchworks mixin for Stanford::Mods::Record" do
+
+  before(:all) do
+    @smods_rec = Stanford::Mods::Record.new
+    @ns_decl = "xmlns='#{Mods::MODS_NS}'"
+  end
+  before :each do
+    @genre = 'genre top level'
+    @cart_coord = '6 00 S, 71 30 E'
+    @s_genre = 'genre in subject'
+    @geo = 'Somewhere'
+    @geo_code = 'us'
+    @hier_geo_country = 'France'
+    @s_name = 'name in subject'
+    @occupation = 'worker bee'
+    @temporal = 'temporal'
+    @s_title = 'title in subject'
+    @topic = 'topic'
+    m = "<mods #{@ns_decl}>
+    <genre>#{@genre}</genre>
+    <subject><cartographics><coordinates>#{@cart_coord}</coordinates></cartographics></subject>
+    <subject><genre>#{@s_genre}</genre></subject>
+    <subject><geographic>#{@geo}</geographic></subject>
+    <subject><geographicCode authority='iso3166'>#{@geo_code}</geographicCode></subject>
+    <subject><hierarchicalGeographic><country>#{@hier_geo_country}</country></hierarchicalGeographic></subject>
+    <subject><name><namePart>#{@s_name}</namePart></name></subject>
+    <subject><occupation>#{@occupation}</occupation></subject>
+    <subject><temporal>#{@temporal}</temporal></subject>
+    <subject><titleInfo><title>#{@s_title}</title></titleInfo></subject>
+    <subject><topic>#{@topic}</topic></subject>      
+    </mods>"
+    @smods_rec = Stanford::Mods::Record.new
+    @smods_rec.from_str(m)
+    @ng_mods = Nokogiri::XML(m)
+    m_no_subject = "<mods #{@ns_decl}><note>notit</note></mods>"
+    @ng_mods_no_subject = Nokogiri::XML(m_no_subject)
+  end
+  
+  context "sw author methods" do
+    before(:all) do
+      m = "<mods #{@ns_decl}>
+      
+      </mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+    end
+    it 'should choose a date ending with CE if there are multiple dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>7192 AM (li-Adam) / 1684 CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1684'
+    end
+    
+  end
+ 
+  context "search fields" do      
+
+    context "topic_search" do
+      before :each do
+        @genre = 'genre top level'
+        @cart_coord = '6 00 S, 71 30 E'
+        @s_genre = 'genre in subject'
+        @geo = 'Somewhere'
+        @geo_code = 'us'
+        @hier_geo_country = 'France'
+        @s_name = 'name in subject'
+        @occupation = 'worker bee'
+        @temporal = 'temporal'
+        @s_title = 'title in subject'
+        @topic = 'topic'
+        m = "<mods #{@ns_decl}>
+        <genre>#{@genre}</genre>
+        <subject><cartographics><coordinates>#{@cart_coord}</coordinates></cartographics></subject>
+        <subject><genre>#{@s_genre}</genre></subject>
+        <subject><geographic>#{@geo}</geographic></subject>
+        <subject><geographicCode authority='iso3166'>#{@geo_code}</geographicCode></subject>
+        <subject><hierarchicalGeographic><country>#{@hier_geo_country}</country></hierarchicalGeographic></subject>
+        <subject><name><namePart>#{@s_name}</namePart></name></subject>
+        <subject><occupation>#{@occupation}</occupation></subject>
+        <subject><temporal>#{@temporal}</temporal></subject>
+        <subject><titleInfo><title>#{@s_title}</title></titleInfo></subject>
+        <subject><topic>#{@topic}</topic></subject>      
+        </mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @ng_mods = Nokogiri::XML(m)
+        m_no_subject = "<mods #{@ns_decl}><note>notit</note></mods>"
+        @ng_mods_no_subject = Nokogiri::XML(m_no_subject)
+      end
+      it "should be nil if there are no values in the MODS" do
+        m = "<mods #{@ns_decl}></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.topic_search.should == nil
+      end
+      it "should contain subject <topic> subelement data" do
+        @smods_rec.topic_search.should include(@topic)
+      end
+      it "should contain top level <genre> element data" do
+        @smods_rec.topic_search.should include(@genre)
+      end
+      it "should not contain other subject element data" do
+        @smods_rec.topic_search.should_not include(@cart_coord)
+        @smods_rec.topic_search.should_not include(@s_genre)
+        @smods_rec.topic_search.should_not include(@geo)
+        @smods_rec.topic_search.should_not include(@geo_code)
+        @smods_rec.topic_search.should_not include(@hier_geo_country)
+        @smods_rec.topic_search.should_not include(@s_name)
+        @smods_rec.topic_search.should_not include(@occupation)
+        @smods_rec.topic_search.should_not include(@temporal)
+        @smods_rec.topic_search.should_not include(@s_title)
+      end
+      it "should not be nil if there are only subject/topic elements (no <genre>)" do
+        m = "<mods #{@ns_decl}><subject><topic>#{@topic}</topic></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.topic_search.should == [@topic]
+      end
+      it "should not be nil if there are only <genre> elements (no subject/topic elements)" do
+        m = "<mods #{@ns_decl}><genre>#{@genre}</genre></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.topic_search.should == [@genre]
+      end
+      context "topic subelement" do
+        it "should have a separate value for each topic element" do
+          m = "<mods #{@ns_decl}>
+          <subject>
+          <topic>first</topic>
+          <topic>second</topic>
+          </subject>
+          <subject><topic>third</topic></subject>
+          </mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          @smods_rec.topic_search.should == ['first', 'second', 'third']
+        end
+        it "should be nil if there are only empty values in the MODS" do
+          m = "<mods #{@ns_decl}><subject><topic/></subject><note>notit</note></mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          @smods_rec.topic_search.should == nil
+        end
+      end
+    end # topic_search
+
+    context "geographic_search" do
+      it "should call sw_geographic_search (from stanford-mods gem)" do
+        m = "<mods #{@ns_decl}><subject><geographic>#{@geo}</geographic></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.should_receive(:sw_geographic_search)
+        @smods_rec.geographic_search
+      end
+      it "should log an info message when it encounters a geographicCode encoding it doesn't translate" do
+        m = "<mods #{@ns_decl}><subject><geographicCode authority='iso3166'>ca</geographicCode></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.sw_logger.should_receive(:info).with(/#{@fake_druid} has subject geographicCode element with untranslated encoding \(iso3166\): <geographicCode authority=.*>ca<\/geographicCode>/)
+        @smods_rec.geographic_search
+      end
+    end # geographic_search
+
+    context "subject_other_search" do
+      
+      it "should call sw_subject_names (from stanford-mods gem)" do
+        @smods_rec.should_receive(:sw_subject_names)
+        @smods_rec.subject_other_search
+      end
+      it "should call sw_subject_titles (from stanford-mods gem)" do
+        @smods_rec.should_receive(:sw_subject_titles)
+        @smods_rec.subject_other_search
+      end
+      it "should be nil if there are no values in the MODS" do
+        m = "<mods #{@ns_decl}></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.subject_other_search.should == nil
+      end
+      it "should contain subject <name> SUBelement data" do
+        @smods_rec.subject_other_search.should include(@s_name)
+      end
+      it "should contain subject <occupation> subelement data" do
+        @smods_rec.subject_other_search.should include(@occupation)
+      end
+      it "should contain subject <titleInfo> SUBelement data" do
+        @smods_rec.subject_other_search.should include(@s_title)
+      end
+      it "should not contain other subject element data" do
+        @smods_rec.subject_other_search.should_not include(@genre)
+        @smods_rec.subject_other_search.should_not include(@cart_coord)
+        @smods_rec.subject_other_search.should_not include(@s_genre)
+        @smods_rec.subject_other_search.should_not include(@geo)
+        @smods_rec.subject_other_search.should_not include(@geo_code)
+        @smods_rec.subject_other_search.should_not include(@hier_geo_country)
+        @smods_rec.subject_other_search.should_not include(@temporal)
+        @smods_rec.subject_other_search.should_not include(@topic)
+      end
+      it "should not be nil if there are only subject/name elements" do
+        m = "<mods #{@ns_decl}><subject><name><namePart>#{@s_name}</namePart></name></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.subject_other_search.should == [@s_name]
+      end
+      it "should not be nil if there are only subject/occupation elements" do
+        m = "<mods #{@ns_decl}><subject><occupation>#{@occupation}</occupation></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  subject_other_search.should == [@occupation]
+      end
+      it "should not be nil if there are only subject/titleInfo elements" do
+        m = "<mods #{@ns_decl}><subject><titleInfo><title>#{@s_title}</title></titleInfo></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  subject_other_search.should == [@s_title]
+      end
+      context "occupation subelement" do
+        it "should have a separate value for each occupation element" do
+          m = "<mods #{@ns_decl}>
+          <subject>
+          <occupation>first</occupation>
+          <occupation>second</occupation>
+          </subject>
+          <subject><occupation>third</occupation></subject>
+          </mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.subject_other_search.should == ['first', 'second', 'third']
+        end
+        it "should be nil if there are only empty values in the MODS" do
+          m = "<mods #{@ns_decl}><subject><occupation/></subject><note>notit</note></mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.    subject_other_search.should == nil
+        end
+      end
+    end # subject_other_search
+
+    context "subject_other_subvy_search" do
+      it "should be nil if there are no values in the MODS" do
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(@ng_mods_no_subject.to_s)
+        
+        @smods_rec.  subject_other_subvy_search.should == nil
+      end
+      it "should contain subject <temporal> subelement data" do
+        @smods_rec.subject_other_subvy_search.should include(@temporal)
+      end
+      it "should contain subject <genre> SUBelement data" do
+        @smods_rec.subject_other_subvy_search.should include(@s_genre)
+      end
+      it "should not contain other subject element data" do
+        @smods_rec.subject_other_subvy_search.should_not include(@genre)
+        @smods_rec.subject_other_subvy_search.should_not include(@cart_coord)
+        @smods_rec.subject_other_subvy_search.should_not include(@geo)
+        @smods_rec.subject_other_subvy_search.should_not include(@geo_code)
+        @smods_rec.subject_other_subvy_search.should_not include(@hier_geo_country)
+        @smods_rec.subject_other_subvy_search.should_not include(@s_name)
+        @smods_rec.subject_other_subvy_search.should_not include(@occupation)
+        @smods_rec.subject_other_subvy_search.should_not include(@topic)
+        @smods_rec.subject_other_subvy_search.should_not include(@s_title)
+      end
+      it "should not be nil if there are only subject/temporal elements (no subject/genre)" do
+        m = "<mods #{@ns_decl}><subject><temporal>#{@temporal}</temporal></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  subject_other_subvy_search.should == [@temporal]
+      end
+      it "should not be nil if there are only subject/genre elements (no subject/temporal)" do
+        m = "<mods #{@ns_decl}><subject><genre>#{@s_genre}</genre></subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  subject_other_subvy_search.should == [@s_genre]
+      end
+      context "temporal subelement" do
+        it "should have a separate value for each temporal element" do
+          m = "<mods #{@ns_decl}>
+          <subject>
+          <temporal>1890-1910</temporal>
+          <temporal>20th century</temporal>
+          </subject>
+          <subject><temporal>another</temporal></subject>
+          </mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.    subject_other_subvy_search.should == ['1890-1910', '20th century', 'another']
+        end
+        it "should log an info message when it encounters an encoding it doesn't translate" do
+          m = "<mods #{@ns_decl}><subject><temporal encoding='iso8601'>197505</temporal></subject></mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.sw_logger.should_receive(:info).with(/#{@fake_druid} has subject temporal element with untranslated encoding: <temporal encoding=.*>197505<\/temporal>/)
+          @smods_rec.subject_other_subvy_search
+        end
+        it "should be nil if there are only empty values in the MODS" do
+          m = "<mods #{@ns_decl}><subject><temporal/></subject><note>notit</note></mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+         
+          @smods_rec.    subject_other_subvy_search.should == nil
+        end
+      end
+      context "genre subelement" do
+        it "should have a separate value for each genre element" do
+          m = "<mods #{@ns_decl}>
+          <subject>
+          <genre>first</genre>
+          <genre>second</genre>
+          </subject>
+          <subject><genre>third</genre></subject>
+          </mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.    subject_other_subvy_search.should == ['first', 'second', 'third']
+        end
+        it "should be nil if there are only empty values in the MODS" do
+          m = "<mods #{@ns_decl}><subject><genre/></subject><note>notit</note></mods>"
+          @smods_rec = Stanford::Mods::Record.new
+          @smods_rec.from_str(m)
+          
+          @smods_rec.    subject_other_subvy_search.should == nil
+        end
+      end
+    end # subject_other_subvy_search
+
+    context "subject_all_search" do
+      it "should be nil if there are no values in the MODS" do
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(@ng_mods_no_subject.to_s)
+
+        @smods_rec.  subject_all_search.should == nil
+      end
+      it "should contain top level <genre> element data" do
+        @smods_rec.subject_all_search.should include(@genre)
+      end
+      it "should not contain cartographic sub element" do
+        @smods_rec.subject_all_search.should_not include(@cart_coord)
+      end
+      it "should not include codes from hierarchicalGeographic sub element" do
+        @smods_rec.subject_all_search.should_not include(@geo_code)
+      end
+      it "should contain all other subject subelement data" do
+        @smods_rec.subject_all_search.should include(@s_genre)
+        @smods_rec.subject_all_search.should include(@geo)
+        @smods_rec.subject_all_search.should include(@hier_geo_country)
+        @smods_rec.subject_all_search.should include(@s_name)
+        @smods_rec.subject_all_search.should include(@occupation)
+        @smods_rec.subject_all_search.should include(@temporal)
+        @smods_rec.subject_all_search.should include(@s_title)
+        @smods_rec.subject_all_search.should include(@topic)
+      end
+    end # subject_all_search
+  end # subject search fields
+
+  context "facet fields" do
+    context "topic_facet" do
+      it "should include topic subelement" do
+        @smods_rec.topic_facet.should include(@topic)
+      end
+      it "should include sw_subject_names" do
+        @smods_rec.topic_facet.should include(@s_name)
+      end
+      it "should include sw_subject_titles" do
+        @smods_rec.topic_facet.should include(@s_title)
+      end
+      it "should include occupation subelement" do
+        @smods_rec.topic_facet.should include(@occupation)
+      end
+      it "should have the trailing punctuation removed" do
+        m = "<mods #{@ns_decl}><subject>
+        <topic>comma,</topic>
+        <occupation>semicolon;</occupation>
+        <titleInfo><title>backslash \\</title></titleInfo>
+        <name><namePart>internal, punct;uation</namePart></name>
+        </subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  topic_facet.should include('comma')
+        @smods_rec.  topic_facet.should include('semicolon')
+        @smods_rec.  topic_facet.should include('backslash')
+        @smods_rec.  topic_facet.should include('internal, punct;uation')
+      end
+      it "should be nil if there are no values" do
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(@ng_mods_no_subject.to_s)
+        @smods_rec.  topic_facet.should == nil
+      end
+    end
+    context "geographic_facet" do
+      it "should call geographic_search" do
+        @smods_rec.should_receive(:geographic_search)
+        @smods_rec.geographic_facet
+      end
+      it "should be like geographic_search with the trailing punctuation (and preceding spaces) removed" do
+        m = "<mods #{@ns_decl}><subject>
+        <geographic>comma,</geographic>
+        <geographic>semicolon;</geographic>
+        <geographic>backslash \\</geographic>
+        <geographic>internal, punct;uation</geographic>
+        </subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  geographic_facet.should include('comma')
+        @smods_rec.  geographic_facet.should include('semicolon')
+        @smods_rec.  geographic_facet.should include('backslash')
+        @smods_rec.  geographic_facet.should include('internal, punct;uation')
+      end
+      it "should be nil if there are no values" do
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(@ng_mods_no_subject.to_s)
+        @smods_rec.  geographic_facet.should == nil
+      end
+    end
+    context "era_facet" do
+      it "should be temporal subelement with the trailing punctuation removed" do
+        m = "<mods #{@ns_decl}><subject>
+        <temporal>comma,</temporal>
+        <temporal>semicolon;</temporal>
+        <temporal>backslash \\</temporal>
+        <temporal>internal, punct;uation</temporal>
+        </subject></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+
+
+        @smods_rec.  era_facet.should include('comma')
+        @smods_rec.  era_facet.should include('semicolon')
+        @smods_rec.  era_facet.should include('backslash')
+        @smods_rec.  era_facet.should include('internal, punct;uation')
+      end
+      it "should be nil if there are no values" do
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(@ng_mods_no_subject.to_s)
+        @smods_rec.  era_facet.should == nil
+      end
+    
+    end # subject facet fields
+    context "pub_dates" do
+      it "should choose the first date" do
+        m = "<mods #{@ns_decl}><originInfo>
+        <dateCreated>1904</dateCreated>
+        <dateCreated>1904</dateCreated>
+        <dateIssued>1906</dateIssued>
+
+        </originInfo></mods>"
+        @smods_rec = Stanford::Mods::Record.new
+        @smods_rec.from_str(m)
+        @smods_rec.pub_dates.should == ['1906','1904','1904']
+      end
+    end
+  end # context sw subject methods 
+  context "pub_date" do
+    it "should choose the first date" do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>1904</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1904'
+    end
+    it "should parse a date" do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>Aug. 3rd, 1886</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1886'
+    end
+    it "should remove question marks and brackets" do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>Aug. 3rd, [18]86?</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1886'
+    end
+    it 'should handle an s after the decade' do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>early 1890s</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1890'
+    end
+    it 'should choose a date ending with CE if there are multiple dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>7192 AM (li-Adam) / 1684 CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1684'
+    end
+    it 'should handle hyphenated range dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>1282 AH / 1865-6 CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1865'
+    end
+    it 'should handle century based dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>13th century AH / 19th CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date_facet.should == '19th century'
+      @smods_rec.pub_date_sort.should =='1800'
+      @smods_rec.pub_date.should == '18--'
+    end
+    it 'should handle multiple CE dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>6 Dhu al-Hijjah 923 AH / 1517 CE -- 7 Rabi I 924 AH / 1518 CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '1517'
+      @smods_rec.pub_date_sort.should =='1517'
+      @smods_rec.pub_date_facet.should == '1517'
+    end
+    it 'should handle this case from walters' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>Late 14th or early 15th century CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '14--'
+      @smods_rec.pub_date_sort.should =='1400'
+      @smods_rec.pub_date_facet.should == '15th century'
+    end
+    it 'should work on 3 digit dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>966 CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date.should == '966'
+      @smods_rec.pub_date_sort.should =='0966'
+      @smods_rec.pub_date_facet.should == '966'
+    end
+    it 'should work on 3 digit dates' do
+      m = "<mods #{@ns_decl}><originInfo><dateIssued>3rd century AH / 9th CE</dateIssued><issuance>monographic</issuance></originInfo>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+    
+      @smods_rec.pub_date.should == '8--'
+      @smods_rec.pub_date_sort.should =='0800'
+      @smods_rec.pub_date_facet.should == '9th century'
+    end
+    
+    
+    
+    
+    
+  end #context pub_dates
+  context 'pub_date_sort' do
+    before :each do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>Aug. 3rd, 1886</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+    
+    end
+    it 'should work on normal dates' do
+      @smods_rec.stub(:pub_date).and_return('1945')
+      @smods_rec.pub_date_sort.should == '1945'
+    end
+    it 'should work on 3 digit dates' do
+      @smods_rec.stub(:pub_date).and_return('945')
+      @smods_rec.pub_date_sort.should == '0945'
+    end
+    it 'should work on century dates' do
+      @smods_rec.stub(:pub_date).and_return('16--')
+      @smods_rec.pub_date_sort.should == '1600'
+    end
+    it 'should work on 3 digit century dates' do
+      @smods_rec.stub(:pub_date).and_return('9--')
+      @smods_rec.pub_date_sort.should == '0900'
+    end
+  end
+
+  context "format" do
+    it "should choose the format" do
+      m = "<mods #{@ns_decl}><typeOfResource>still image</typeOfResouce></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.format.should == ['Image']
+    end
+    it "should return nothing if there is no format info" do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>1904</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.format.should == []
+    end
+  end#context format
+  context "pub_date_groups" do
+    it 'should generate the groups' do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>1904</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+    
+      @smods_rec.pub_date_groups(1904).should == ['More than 50 years ago']
+    end
+    it 'should work for a modern date too' do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>1904</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date_groups(2013).should == ["This year"]
+    end
+    it 'should work ok given a nil date' do
+      m = "<mods #{@ns_decl}><originInfo>
+      <dateCreated>1904</dateCreated>
+      </originInfo></mods>"
+      @smods_rec = Stanford::Mods::Record.new
+      @smods_rec.from_str(m)
+      @smods_rec.pub_date_groups(nil).should == nil
+    end
+  end#context pub date groups
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stanford-mods
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-23 00:00:00.000000000 Z
+date: 2013-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mods
@@ -151,6 +151,7 @@ files:
 - lib/stanford-mods/version.rb
 - spec/kolb_spec.rb
 - spec/name_spec.rb
+- spec/searchworks_gdor_spec.rb
 - spec/searchworks_spec.rb
 - spec/searchworks_subject_spec.rb
 - spec/spec_helper.rb
@@ -169,7 +170,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2062019389592910625
+      hash: 823695280464572683
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -178,16 +179,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2062019389592910625
+      hash: 823695280464572683
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Stanford specific wrangling of MODS metadata
 test_files:
 - spec/kolb_spec.rb
 - spec/name_spec.rb
+- spec/searchworks_gdor_spec.rb
 - spec/searchworks_spec.rb
 - spec/searchworks_subject_spec.rb
 - spec/spec_helper.rb