stanford-mods 1.5.2 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1edee19ce68af157f4912685e670abd888bc4353
-  data.tar.gz: dfed761858e10ec8c4909d28c8f1a245c9a3d8b9
+  metadata.gz: 80b7166744ed54bca31cdcbfa1f400d5e05e3e24
+  data.tar.gz: 41439aae07f4ab0d35913284f6c5d3ca3db85f1a
 SHA512:
-  metadata.gz: 31183275be3ff6bffb919d900cdc7ba7cd7f7831d8beb9148d12c63ff6a7263f769bc7bad2248297ddf767ae17629785ff8ef36fd4bfead5590cc8e3e427843b
-  data.tar.gz: 113574dfe94ef773584af8006d127c5773e373d73efdf2535748ea690231d4ff2143c24d900ad58fe568c93ebb1c6ae8d517e2bdc63693be3d3f23f10697f1ce
+  metadata.gz: 6640e0395f1a500507ea4be9daccb561c85a6f0f02eff01a0e32260efe424cc4bb97a6ece0968a55d0bfbfdad8b45bac0e6ea6362edc6df6d242f32ee2829db2
+  data.tar.gz: bf70600680517f261d291d5e377838b6d5b2aad36288bdc238e2b87e9bfbc2d2cf1c70b0c7aa3727f9655d0513cdf30d8290ece7f7e546de43955737777bc7f3

data/lib/stanford-mods/date_parsing.rb

@@ -7,16 +7,13 @@ module Stanford
     #     - we could add methods like my_date.bc?
     class DateParsing
 
-      # get single facet value for date, generally an explicit year or "17th century" or "5 B.C."
-      #   returns '845', not 0845
-      # @param [String] date_str String containing a date (we hope)
-      # @return [String, nil] String facet value for year if we could parse one, nil otherwise
-      def self.facet_string_from_date_str(date_str)
-        DateParsing.new(date_str).facet_string_from_date_str
+      # get display value for year, generally an explicit year or "17th century" or "5 B.C." or "1950s" or '845 A.D.'
+      # @return [String, nil] display value for year if we could parse one, nil otherwise
+      def self.date_str_for_display(date_str)
+        DateParsing.new(date_str).date_str_for_display
       end
 
       # get year as Integer if we can parse date_str to get a year.
-      # @param [String] date_str String containing a date (we hope)
       # @return [Integer, nil] Integer year if we could parse one, nil otherwise
       def self.year_int_from_date_str(date_str)
         DateParsing.new(date_str).year_int_from_date_str
@@ -25,7 +22,6 @@ module Stanford
       # get String sortable value year if we can parse date_str to get a year.
       #   SearchWorks currently uses a string field for pub date sorting; thus so does Spotlight.
       #   The values returned must *lexically* sort in chronological order, so the B.C. dates are tricky
-      # @param [String] date_str String containing a date (we hope)
       # @return [String, nil] String sortable year if we could parse one, nil otherwise
       #  note that these values must *lexically* sort to create a chronological sort.
       def self.sortable_year_string_from_date_str(date_str)
@@ -56,25 +52,27 @@ module Stanford
 
       BRACKETS_BETWEEN_DIGITS_REXEXP = Regexp.new('\d[' + Regexp.escape('[]') + ']\d')
 
-      # get single facet value for date, generally an explicit year or "17th century" or "5 B.C."
-      # @return [String, nil] String facet value for year if we could parse one, nil otherwise
-      def facet_string_from_date_str
+      # get display value for year, generally an explicit year or "17th century" or "5 B.C." or "1950s" or '845 A.D.'
+      # @return [String, nil] String value for year if we could parse one, nil otherwise
+      def date_str_for_display
         return if orig_date_str == '0000-00-00' # shpc collection has these useless dates
         # B.C. first in case there are 4 digits, e.g. 1600 B.C.
-        return facet_string_for_bc if orig_date_str.match(BC_REGEX)
-        result = sortable_year_for_yyyy_yy_or_decade
+        return display_str_for_bc if orig_date_str.match(BC_REGEX)
+        # decade next in case there are 4 digits, e.g. 1950s
+        return display_str_for_decade if orig_date_str.match(DECADE_4CHAR_REGEXP) || orig_date_str.match(DECADE_S_REGEXP)
+        result = sortable_year_for_yyyy_or_yy
         unless result
           # try removing brackets between digits in case we have 169[5] or [18]91
           no_brackets = remove_brackets
-          return DateParsing.new(no_brackets).facet_string_from_date_str if no_brackets
+          return DateParsing.new(no_brackets).date_str_for_display if no_brackets
         end
         # parsing below this line gives string inapprop for year_str_valid?
         unless self.class.year_str_valid?(result)
-          result = facet_string_for_century
-          result ||= facet_string_for_early_numeric
+          result = display_str_for_century
+          result ||= display_str_for_early_numeric
         end
         # remove leading 0s from early dates
-        result = result.to_i.to_s if result && result.match(/^\d+$/)
+        result = "#{result.to_i} A.D." if result && result.match(/^0\d+$/)
         result
       end
 
@@ -84,7 +82,8 @@ module Stanford
         return if orig_date_str == '0000-00-00' # shpc collection has these useless dates
         # B.C. first in case there are 4 digits, e.g. 1600 B.C.
         return sortable_year_int_for_bc if orig_date_str.match(BC_REGEX)
-        result = sortable_year_for_yyyy_yy_or_decade
+        result = sortable_year_for_yyyy_or_yy
+        result ||= sortable_year_for_decade # 19xx or 20xx
         result ||= sortable_year_for_century
         result ||= sortable_year_int_for_early_numeric
         unless result
@@ -104,7 +103,8 @@ module Stanford
         return if orig_date_str == '0000-00-00' # shpc collection has these useless dates
         # B.C. first in case there are 4 digits, e.g. 1600 B.C.
         return sortable_year_str_for_bc if orig_date_str.match(BC_REGEX)
-        result = sortable_year_for_yyyy_yy_or_decade
+        result = sortable_year_for_yyyy_or_yy
+        result ||= sortable_year_for_decade # 19xx or 20xx
         result ||= sortable_year_for_century
         result ||= sortable_year_str_for_early_numeric
         unless result
@@ -118,11 +118,10 @@ module Stanford
       # get String sortable value year if we can parse date_str to get a year.
       # @return [String, nil] String sortable year if we could parse one, nil otherwise
       #  note that these values must *lexically* sort to create a chronological sort.
-      def sortable_year_for_yyyy_yy_or_decade
+      def sortable_year_for_yyyy_or_yy
         # most date strings have a four digit year
         result = sortable_year_for_yyyy
         result ||= sortable_year_for_yy # 19xx or 20xx
-        result ||= sortable_year_for_decade # 19xx or 20xx
         result
       end
 
@@ -161,15 +160,34 @@ module Stanford
         nil # explicitly want nil if date won't parse
       end
 
+      DECADE_4CHAR_REGEXP = Regexp.new('(^|\D)\d{3}[u\-?x]')
+
       # get first year of decade (as String) if we have:  yyyu, yyy-, yyy? or yyyx pattern
       #   note that these are the only decade patterns found in our actual date strings in MODS records
       # @return [String, nil] 4 digit year (e.g. 1860, 1950) if orig_date_str matches pattern, nil otherwise
       def sortable_year_for_decade
-        decade_matches = orig_date_str.match(/\d{3}[u\-?x]/) if orig_date_str
+        decade_matches = orig_date_str.match(DECADE_4CHAR_REGEXP) if orig_date_str
         changed_to_zero = decade_matches.to_s.tr('u\-?x', '0') if decade_matches
         DateParsing.new(changed_to_zero).sortable_year_for_yyyy if changed_to_zero
       end
 
+      DECADE_S_REGEXP = Regexp.new('\d{3}0\'?s')
+
+      # get, e.g. 1950s, if we have:  yyyu, yyy-, yyy? or yyyx pattern or  yyy0s or yyy0's
+      #   note that these are the only decade patterns found in our actual date strings in MODS records
+      # @return [String, nil] 4 digit year with s (e.g. 1860s, 1950s) if orig_date_str matches pattern, nil otherwise
+      def display_str_for_decade
+        decade_matches = orig_date_str.match(DECADE_4CHAR_REGEXP) if orig_date_str
+        if decade_matches
+          changed_to_zero = decade_matches.to_s.tr('u\-?x', '0') if decade_matches
+          zeroth_year = DateParsing.new(changed_to_zero).sortable_year_for_yyyy if changed_to_zero
+          return "#{zeroth_year}s" if zeroth_year
+        else
+          decade_matches = orig_date_str.match(DECADE_S_REGEXP) if orig_date_str
+          return decade_matches.to_s.tr("'", '') if decade_matches
+        end
+      end
+
       CENTURY_WORD_REGEXP = Regexp.new('(\d{1,2}).*century')
       CENTURY_4CHAR_REGEXP = Regexp.new('(\d{1,2})[u\-]{2}')
 
@@ -192,10 +210,10 @@ module Stanford
         end
       end
 
-      # get single facet value for century (17th century) if we have:  yyuu, yy--, yy--? or xxth century pattern
+      # get display value for century (17th century) if we have:  yyuu, yy--, yy--? or xxth century pattern
       #   note that these are the only century patterns found in our actual date strings in MODS records
       # @return [String, nil] yy(th) Century if orig_date_str matches pattern, nil otherwise; also nil if B.C. in pattern
-      def facet_string_for_century
+      def display_str_for_century
         return unless orig_date_str
         return if orig_date_str.match(/B\.C\./)
         century_str_matches = orig_date_str.match(CENTURY_WORD_REGEXP)
@@ -228,9 +246,9 @@ module Stanford
         "-#{$1}".to_i if bc_matches
       end
 
-      # get single facet value for B.C. if we have  B.C. pattern
+      # get display value for B.C. if we have  B.C. pattern
       # @return [String, nil] ddd B.C.  if ddd B.C. in pattern; nil otherwise
-      def facet_string_for_bc
+      def display_str_for_bc
         bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
         bc_matches.to_s if bc_matches
       end
@@ -261,14 +279,14 @@ module Stanford
         orig_date_str.to_i if orig_date_str.match(/^-\d{4}$/)
       end
 
-      # get single facet value for date String containing yyy, yy, y, -y, -yy, -yyy
+      # get display value for date String containing yyy, yy, y, -y, -yy, -yyy
       #   negative number strings will be changed to B.C. strings
-      def facet_string_for_early_numeric
+      def display_str_for_early_numeric
         return unless orig_date_str.match(EARLY_NUMERIC)
         # negative number becomes B.C.
-        return orig_date_str[1..-1] + " B.C." if orig_date_str.match(/^\-/)
+        return  "#{orig_date_str[1..-1]} B.C." if orig_date_str.match(/^\-/)
         # remove leading 0s from early dates
-        orig_date_str.to_i.to_s
+        "#{orig_date_str.to_i} A.D."
       end
 
       # NOTE:  while Date.parse() works for many dates, the *sortable_year_for_yyyy

data/lib/stanford-mods/origin_info.rb

@@ -4,7 +4,7 @@ require 'mods'
 # Parsing MODS /originInfo for Publication/Imprint data:
 #  * pub year for date slider facet
 #  * pub year for sorting
-#  * pub year for single facet value
+#  * pub year for single display value
 #  * imprint info for display
 #  *
 # These methods may be used by searchworks.rb file or by downstream apps
@@ -12,16 +12,6 @@ module Stanford
   module Mods
     class Record < ::Mods::Record
 
-      # return a single string intended for facet use for pub date
-      # prefer dateIssued (any) before dateCreated (any) before dateCaptured (any)
-      #  look for a keyDate and use it if there is one;  otherwise pick earliest date
-      # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
-      #   should be ignored; false if approximate dates should be included
-      # @return [String] single String containing publication year for facet use
-      def pub_date_facet_single_value(ignore_approximate = false)
-        single_pub_year(ignore_approximate, :year_facet_str)
-      end
-
       # return pub year as an Integer
       # prefer dateIssued (any) before dateCreated (any) before dateCaptured (any)
       #  look for a keyDate and use it if there is one;  otherwise pick earliest date
@@ -45,15 +35,53 @@ module Stanford
         single_pub_year(ignore_approximate, :year_sort_str)
       end
 
+      # return a single string intended for display of pub year
+      # 0 < year < 1000:  add A.D. suffix
+      # year < 0:  add B.C. suffix.  ('-5'  =>  '5 B.C.', '700 B.C.'  => '700 B.C.')
+      # 195u =>  195x
+      # 19uu => 19xx
+      #   '-5'  =>  '5 B.C.'
+      #   '700 B.C.'  => '700 B.C.'
+      #   '7th century' => '7th century'
+      # date ranges?
+      # prefer dateIssued (any) before dateCreated (any) before dateCaptured (any)
+      #  look for a keyDate and use it if there is one;  otherwise pick earliest date
+      # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
+      #   should be ignored; false if approximate dates should be included
+      def pub_year_display_str(ignore_approximate = false)
+        single_pub_year(ignore_approximate, :year_display_str)
+
+        # TODO: want range displayed when start and end points
+        # TODO: also want best year in year_isi fields
+        # get_main_title_date
+        # https://github.com/sul-dlss/SearchWorks/blob/7d4d870a9d450fed8b081c38dc3dbd590f0b706e/app/helpers/results_document_helper.rb#L8-L46
+
+        #"publication_year_isi"   => "Publication date",  <--  do it already
+        #"beginning_year_isi"     => "Beginning date",
+        #"earliest_year_isi"      => "Earliest date",
+        #"earliest_poss_year_isi" => "Earliest possible date",
+        #"ending_year_isi"        => "Ending date",
+        #"latest_year_isi"        => "Latest date",
+        #"latest_poss_year_isi"   => "Latest possible date",
+        #"production_year_isi"    => "Production date",
+        #"original_year_isi"      => "Original date",
+        #"copyright_year_isi"     => "Copyright date"} %>
+
+        #"creation_year_isi"      => "Creation date",  <--  do it already
+        #{}"release_year_isi"       => "Release date",
+        #{}"reprint_year_isi"       => "Reprint/reissue date",
+        #{}"other_year_isi"         => "Date",
+      end
+
       # given the passed date elements, look for a single keyDate and use it if there is one;
       #    otherwise pick earliest parseable date
       # @param [Array<Nokogiri::XML::Element>] date_el_array the elements from which to select a pub date
-      # @return [String] single String containing publication year for facet use
-      def year_facet_str(date_el_array)
-        result = date_parsing_result(date_el_array, :facet_string_from_date_str)
+      # @return [String] single String containing publication year for display
+      def year_display_str(date_el_array)
+        result = date_parsing_result(date_el_array, :date_str_for_display)
         return result if result
         _ignore, orig_str_to_parse = self.class.earliest_year_str(date_el_array)
-        DateParsing.facet_string_from_date_str(orig_str_to_parse) if orig_str_to_parse
+        DateParsing.date_str_for_display(orig_str_to_parse) if orig_str_to_parse
       end
 
       # given the passed date elements, look for a single keyDate and use it if there is one;
@@ -205,8 +233,8 @@ module Stanford
       #   Spotlight:  pub_date field should be replaced by pub_year_w_approx_isi and pub_year_no_approx_isi
       #   SearchWorks:  pub_date field used for display in search results and show view; for sorting nearby-on-shelf
       #      these could be done with more approp fields/methods (pub_year_int for sorting;  new pub year methods to populate field)
-      # TODO:  prob should deprecated this in favor of pub_date_facet_single_value;
-      #    need head-to-head testing with pub_date_facet_single_value
+      # TODO:  prob should deprecate this in favor of pub_year_display_str;
+      #    need head-to-head testing with pub_year_display_str
       # @return <Array[String]> with values for the pub date facet
       def pub_date_facet
         if pub_date

data/lib/stanford-mods/searchworks.rb

@@ -366,6 +366,10 @@ module Stanford
             end
           end
         end
+        # Archived website is in the MODS genre tag but it is considered a
+        # Resource type for Searchworks, so it needs to be removed from the
+        # applicable genre values
+        val.delete 'Archived website'
         val.uniq
       end
 

data/lib/stanford-mods/version.rb

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

data/spec/date_parsing_spec.rb

@@ -388,10 +388,10 @@ describe "date parsing methods" do
     '8 B.C.' => -8
   }
 
-  context '*facet_string_from_date_str' do
-    it 'calls instance method facet_string_from_date_str' do
-      expect_any_instance_of(Stanford::Mods::DateParsing).to receive(:facet_string_from_date_str)
-      Stanford::Mods::DateParsing.facet_string_from_date_str('1666')
+  context '*date_str_for_display' do
+    it 'calls instance method date_str_for_display' do
+      expect_any_instance_of(Stanford::Mods::DateParsing).to receive(:date_str_for_display)
+      Stanford::Mods::DateParsing.date_str_for_display('1666')
     end
   end
   context '*sortable_year_string_from_date_str' do
@@ -407,7 +407,7 @@ describe "date parsing methods" do
     end
   end
 
-  context '#facet_string_from_date_str' do
+  context '#date_str_for_display' do
     single_year
       .merge(specific_month)
       .merge(specific_day)
@@ -417,41 +417,48 @@ describe "date parsing methods" do
       .merge(brackets_in_middle_of_year)
       .merge(invalid_but_can_get_year).each do |example, expected|
       expected = expected.to_i.to_s if expected.match(/^\d+$/)
+      expected = "#{expected} A.D." if expected.match(/^\d{1,3}$/)
       it "#{expected} for single value #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq expected
+        expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq expected
       end
     end
 
-    multiple_years
-      .merge(multiple_years_4_digits_once)
-      .merge(decade_only)
+    decade_only
       .merge(decade_only_4_digits).each do |example, expected|
+      expected = "#{expected.first.to_i}s" if expected.first.match(/^\d+$/)
+      it "#{expected} for decade #{example}" do
+        expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq expected
+      end
+    end
+
+    multiple_years
+      .merge(multiple_years_4_digits_once).each do |example, expected|
       it "#{expected.first} for multi-value #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq expected.first
+        expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq expected.first
       end
     end
 
     early_numeric_dates.each do |example, expected|
       if example.start_with?('-')
-        exp = example[1..-1] + " B.C."
+        exp = "#{example[1..-1]} B.C."
         it "#{exp} for #{example}" do
-          expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq exp
+          expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq exp
         end
       else
-        expected = expected.to_i.to_s if expected.match(/^\d+$/)
+        expected = "#{expected.to_i} A.D." if expected.match(/^\d+$/)
         it "#{expected} for #{example}" do
-          expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq expected
+          expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq expected
         end
       end
     end
 
     bc_dates.keys.each do |example|
       it "#{example} for #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq example
+        expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq example
       end
     end
     it '1600 B.C. for 1600 B.C.' do
-      expect(Stanford::Mods::DateParsing.new('1600 B.C.').facet_string_from_date_str).to eq '1600 B.C.'
+      expect(Stanford::Mods::DateParsing.new('1600 B.C.').date_str_for_display).to eq '1600 B.C.'
     end
 
     [ # bad dates
@@ -461,7 +468,7 @@ describe "date parsing methods" do
       'uuuu'
     ].each do |example|
       it "nil for #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_from_date_str).to eq nil
+        expect(Stanford::Mods::DateParsing.new(example).date_str_for_display).to eq nil
       end
     end
   end
@@ -701,6 +708,34 @@ describe "date parsing methods" do
     end
   end
 
+  context '#display_str_for_decade' do
+    decade_only.each do |example, expected|
+      it "#{expected.first} for #{example}" do
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_decade).to eq "#{expected.first}s"
+      end
+    end
+    { # example string as key, expected result as value
+      '199u' => '1990s',
+      '200-' => '2000s',
+      '201?' => '2010s',
+      '202x' => '2020s',
+      'early 1890s' => '1890s',
+      '1950s' => '1950s',
+      "1950's" => '1950s'
+    }.each do |example, expected|
+      it "#{expected} for #{example}" do
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_decade).to eq expected
+      end
+    end
+
+    # some of the strings this method cannot handle (so must be parsed with other instance methods)
+    specific_day_2_digit_year.keys.each do |example|
+      it "nil for #{example}" do
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_decade).to eq nil
+      end
+    end
+  end
+
   context '#sortable_year_for_century' do
     century_only.keys.each do |example|
       it "1700 from #{example}" do
@@ -715,10 +750,10 @@ describe "date parsing methods" do
     end
   end
 
-  context '#facet_string_for_century' do
+  context '#display_str_for_century' do
     century_only.each do |example, expected|
       it "#{expected} for #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_for_century).to eq expected
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_century).to eq expected
       end
     end
     { # example string as key, expected result as value
@@ -730,12 +765,12 @@ describe "date parsing methods" do
       '2--' => '3rd century'
     }.each do |example, expected|
       it "#{expected} for #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_for_century).to eq expected
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_century).to eq expected
       end
     end
 
     it 'nil for 7th century B.C. (to be handled in different method)' do
-      expect(Stanford::Mods::DateParsing.new('7th century B.C.').facet_string_for_century).to eq nil
+      expect(Stanford::Mods::DateParsing.new('7th century B.C.').display_str_for_century).to eq nil
     end
   end
 
@@ -755,17 +790,18 @@ describe "date parsing methods" do
     end
   end
 
-  context '#facet_string_for_early_numeric' do
+  context '#display_str_for_early_numeric' do
     early_numeric_dates.each do |example, expected|
       expected = expected.to_i.to_s if expected.match(/^\d+$/)
       if example.start_with?('-')
-        exp = example[1..-1] + " B.C."
+        exp = "#{example[1..-1]} B.C."
         it "#{exp} for #{example}" do
-          expect(Stanford::Mods::DateParsing.new(example).facet_string_for_early_numeric).to eq exp
+          expect(Stanford::Mods::DateParsing.new(example).display_str_for_early_numeric).to eq exp
         end
       else
+        exp = "#{expected} A.D."
         it "#{expected} for #{example}" do
-          expect(Stanford::Mods::DateParsing.new(example).facet_string_for_early_numeric).to eq expected
+          expect(Stanford::Mods::DateParsing.new(example).display_str_for_early_numeric).to eq exp
         end
       end
     end
@@ -787,14 +823,14 @@ describe "date parsing methods" do
     end
   end
 
-  context '#facet_string_for_bc' do
+  context '#display_str_for_bc' do
     bc_dates.keys.each do |example|
       it "#{example} for #{example}" do
-        expect(Stanford::Mods::DateParsing.new(example).facet_string_for_bc).to eq example
+        expect(Stanford::Mods::DateParsing.new(example).display_str_for_bc).to eq example
       end
     end
     it '1600 B.C. for 1600 B.C.' do
-      expect(Stanford::Mods::DateParsing.new('1600 B.C.').facet_string_for_bc).to eq '1600 B.C.'
+      expect(Stanford::Mods::DateParsing.new('1600 B.C.').display_str_for_bc).to eq '1600 B.C.'
     end
   end