stanford-mods 1.3.3 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 821295322c2777baac42e0142a690a24b44cf931
-  data.tar.gz: 0134f68110a263ddedf3fb9fec7439bedbbad6dd
+  metadata.gz: 8ea1bae95a44c285bf8594fa40a73c2aa0b328d1
+  data.tar.gz: 479f7c52ae3c7c29592a870a819e10e6e1abb692
 SHA512:
-  metadata.gz: d9976025d220435fc45c4f97901bba4ef506b5e0f3c503b3fb377f3a6a10f4bb74239802abf66fb407c23a121b4339451511485ca94cd06fa620ddec8223fa92
-  data.tar.gz: 758b2840f7bb52959d4bf5ffceb0e9d281325ff5adcf848176535aa9b2a81f98386bfdfbcc03374c8b1622b99b3bb01184e38cb66ef460c95187a8272c9ff0cf
+  metadata.gz: b6f535642244577ecfb2f7cc2d4b4291c9a7cb052869543cf989f6cce72cb5b8609e668e4ace238940c2c252b8613e63908b6627aef608b5e716068b52de23f5
+  data.tar.gz: 97db3a6affbc9e74b62432961d712ace6f860cbf77b36137f22287f2e3c4f491d5cbfeeb24a540bd7c48ed21e38e91663d0dd9436e2cc62e7835bc50bd319a11

data/.gitignore

@@ -22,3 +22,4 @@ tmp
 *.tmproj
 tmtags
 .idea/*
+.pry_history

data/.rspec

@@ -1 +1,2 @@
 --color
+--require spec_helper

data/.rubocop.yml

@@ -4,3 +4,7 @@ require: rubocop-rspec
 
 Metrics/LineLength:
   Max: 120
+
+# shut hound up re: quote styles
+Style/StringLiterals:
+  Enabled: false

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 group :test, :development do
   gem 'rubocop', require: false
   gem 'rubocop-rspec', require: false
+  gem 'pry-byebug', require: false, platform: [:ruby_20, :ruby_21]
 end
 
 group :test do

data/lib/stanford-mods.rb

@@ -1,16 +1,16 @@
-require 'stanford-mods/version'
 require 'mods'
+require 'stanford-mods/date_parsing'
+require 'stanford-mods/geo_spatial'
 require 'stanford-mods/name'
-require 'stanford-mods/searchworks'
+require 'stanford-mods/origin_info'
 require 'stanford-mods/physical_location'
-require 'stanford-mods/geo_spatial'
+require 'stanford-mods/searchworks'
+require 'stanford-mods/version'
 
 # Stanford specific wranglings of MODS metadata as an extension of the Mods::Record object
 module Stanford
   module Mods
-
     class Record < ::Mods::Record
-
     end # Record class
   end # Mods module
 end # Stanford module

data/lib/stanford-mods/date_parsing.rb

@@ -0,0 +1,245 @@
+module Stanford
+  module Mods
+    # Parsing date strings
+    # TODO:  this should become its own gem and/or become eclipsed by/merged with timetwister gem
+    #   When this is "gemified":
+    #     - we may want an integer or date sort field as well as lexical
+    #     - 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)
+        return DateParsing.new(date_str).facet_string_from_date_str
+      end
+
+      # 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)
+        return DateParsing.new(date_str).sortable_year_string_from_date_str
+      end
+
+      # true if the year is between -999 and (current year + 1)
+      # @param [String] year_str String containing a date in format: -yyy, -yy, -y, y, yy, yyy, yyyy
+      # @return [Boolean] true if the year is between -999 and (current year + 1); false otherwise
+      def self.year_str_valid?(year_str)
+        return false unless year_str && (year_str.match(/^\d{1,4}$/) || year_str.match(/^-\d{1,3}$/))
+        (-1000 < year_str.to_i) && (year_str.to_i < Date.today.year + 2)
+      end
+
+      attr_reader :orig_date_str
+
+      def initialize(date_str)
+        @orig_date_str = date_str
+        @orig_date_str.freeze
+      end
+
+      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
+        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)
+        # most date strings have a four digit year
+        result ||= sortable_year_for_yyyy
+        # 2 digit year will always be 19xx or 20xx; sortable version will make a good facet string
+        result ||= sortable_year_for_yy
+        # decades are always 19xx or 20xx; sortable version will make a good facet string
+        result ||= sortable_year_for_decade
+        unless result
+          # try removing brackets between digits in case we have 169[5] or [18]91
+          if orig_date_str.match(BRACKETS_BETWEEN_DIGITS_REXEXP)
+            no_brackets = orig_date_str.delete('[]')
+            return DateParsing.new(no_brackets).facet_string_from_date_str
+          end
+        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
+        end
+        # remove leading 0s from early dates
+        result = result.to_i.to_s if result && result.match(/^\d+$/)
+        result
+      end
+
+      # 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
+      # @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_string_from_date_str
+        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_for_bc if orig_date_str.match(BC_REGEX)
+        # most date strings have a four digit year
+        result = sortable_year_for_yyyy
+        result ||= sortable_year_for_yy
+        result ||= sortable_year_for_decade
+        result ||= sortable_year_for_century
+        result ||= sortable_year_for_early_numeric
+        unless result
+          # try removing brackets between digits in case we have 169[5] or [18]91
+          if orig_date_str.match(BRACKETS_BETWEEN_DIGITS_REXEXP)
+            no_brackets = orig_date_str.delete('[]')
+            return DateParsing.new(no_brackets).sortable_year_string_from_date_str
+          end
+        end
+        result if self.class.year_str_valid?(result)
+      end
+
+      # looks for 4 consecutive digits in orig_date_str and returns first occurrence if found
+      # @return [String, nil] 4 digit year (e.g. 1865, 0950) if orig_date_str has yyyy, nil otherwise
+      def sortable_year_for_yyyy
+        matches = orig_date_str.match(/\d{4}/) if orig_date_str
+        return matches.to_s if matches
+      end
+
+      # returns 4 digit year as String if we have a x/x/yy or x-x-yy pattern
+      #   note that these are the only 2 digit year patterns found in our actual date strings in MODS records
+      #   we use 20 as century digits unless it is greater than current year:
+      #   1/1/15  ->  2015
+      #   1/1/25  ->  1925
+      # @return [String, nil] 4 digit year (e.g. 1865, 0950) if orig_date_str matches pattern, nil otherwise
+      def sortable_year_for_yy
+        return unless orig_date_str
+        slash_matches = orig_date_str.match(/\d{1,2}\/\d{1,2}\/\d{2}/)
+        if slash_matches
+          date_obj = Date.strptime(orig_date_str, '%m/%d/%y')
+        else
+          hyphen_matches = orig_date_str.match(/\d{1,2}-\d{1,2}-\d{2}/)
+          date_obj = Date.strptime(orig_date_str, '%m-%d-%y') if hyphen_matches
+        end
+        if date_obj && date_obj > Date.today
+          date_obj = Date.new(date_obj.year - 100, date_obj.month, date_obj.mday)
+        end
+        date_obj.year.to_s if date_obj
+      rescue ArgumentError
+        nil # explicitly want nil if date won't parse
+      end
+
+      # 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
+        if decade_matches
+          changed_to_zero = decade_matches.to_s.tr('u\-?x', '0')
+          return DateParsing.new(changed_to_zero).sortable_year_for_yyyy
+        end
+      end
+
+      CENTURY_WORD_REGEXP = Regexp.new('(\d{1,2}).*century')
+      CENTURY_4CHAR_REGEXP = Regexp.new('(\d{1,2})[u\-]{2}')
+
+      # get first year of century (as String) 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] yy00 if orig_date_str matches pattern, nil otherwise; also nil if B.C. in pattern
+      def sortable_year_for_century
+        return unless orig_date_str
+        return if orig_date_str.match(/B\.C\./)
+        century_matches = orig_date_str.match(CENTURY_4CHAR_REGEXP)
+        if century_matches
+          return $1 + '00' if $1.length == 2
+          return '0' + $1 + '00' if $1.length == 1
+        end
+        century_str_matches = orig_date_str.match(CENTURY_WORD_REGEXP)
+        if century_str_matches
+          yy = ($1.to_i - 1).to_s
+          return yy + '00' if yy.length == 2
+          return '0' + yy + '00' if yy.length == 1
+        end
+      end
+
+      # get single facet 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
+        return unless orig_date_str
+        return if orig_date_str.match(/B\.C\./)
+        century_str_matches = orig_date_str.match(CENTURY_WORD_REGEXP)
+        return century_str_matches.to_s if century_str_matches
+
+        century_matches = orig_date_str.match(CENTURY_4CHAR_REGEXP)
+        if century_matches
+          require 'active_support/core_ext/integer/inflections'
+          return "#{($1.to_i + 1).ordinalize} century"
+        end
+      end
+
+      BC_REGEX = Regexp.new('(\d{1,4}).*' + Regexp.escape('B.C.'))
+
+      # get String sortable value for B.C. if we have  B.C. pattern
+      #  note that these values must *lexically* sort to create a chronological sort.
+      #  We know our data does not contain B.C. dates older than 999, so we can make them
+      #  lexically sort by subtracting 1000.  So we get:
+      #    -700 for 300 B.C., -750 for 250 B.C., -800 for 200 B.C., -801 for 199 B.C.
+      # @return [String, nil] String sortable -ddd if B.C. in pattern; nil otherwise
+      def sortable_year_for_bc
+        bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
+        return ($1.to_i - 1000).to_s if bc_matches
+      end
+
+      # get single facet 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
+        bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
+        return bc_matches.to_s if bc_matches
+      end
+
+      EARLY_NUMERIC = Regexp.new('^\-?\d{1,3}$')
+
+      # get String sortable value from date String containing yyy, yy, y, -y, -yy, -yyy
+      #  note that these values must *lexically* sort to create a chronological sort.
+      #  We know our data does not contain negative dates older than -999, so we can make them
+      #  lexically sort by subtracting 1000.  So we get:
+      #    -983 for -17, -999 for -1, 0000 for 0, 0001 for 1, 0017 for 17
+      # @return [String, nil] String sortable -ddd if orig_date_str matches pattern; nil otherwise
+      def sortable_year_for_early_numeric
+        return unless orig_date_str.match(EARLY_NUMERIC)
+        if orig_date_str.match(/^\-/)
+          # negative number becomes x - 1000 for sorting; -005 for -995
+          num = orig_date_str[1..-1].to_i - 1000
+          return '-' + num.to_s[1..-1].rjust(3, '0')
+        else
+          return orig_date_str.rjust(4, '0')
+        end
+      end
+
+      # get single facet 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
+        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(/^\-/)
+        # remove leading 0s from early dates
+        orig_date_str.to_i.to_s
+      end
+
+      # NOTE:  while Date.parse() works for many dates, the *sortable_year_for_yyyy
+      #   actually works for nearly all those cases and a lot more besides.  Trial and error
+      #   with an extensive set of test data culled from actual date strings in our MODS records
+      #   has made this method bogus.
+      # @return [String, nil] sortable 4 digit year (e.g. 1865, 0950) if orig_date_str is parseable via ruby Date, nil otherwise
+      def year_via_ruby_parsing
+        return unless orig_date_str.match(/\d\d/) # need at least 2 digits
+        # need more in string than only 2 digits
+        return if orig_date_str.match(/^\d\d$/) || orig_date_str.match(/^\D*\d\d\D*$/)
+        return if orig_date_str.match(/\d\s*B.C./) # skip B.C. dates
+        date_obj = Date.parse(orig_date_str)
+        date_obj.year.to_s
+      rescue ArgumentError
+        nil # explicitly want nil if date won't parse
+      end
+
+    end
+  end
+end

data/lib/stanford-mods/origin_info.rb

@@ -0,0 +1,411 @@
+require 'logger'
+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
+#  * imprint info for display
+#  *
+# These methods may be used by searchworks.rb file or by downstream apps
+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)
+        # prefer dateIssued
+        result = pub_date_best_single_facet_value(date_issued_elements(ignore_approximate))
+        result ||= pub_date_best_single_facet_value(date_created_elements(ignore_approximate))
+        # dateCaptured for web archive seed records
+        result ||= pub_date_best_single_facet_value(@mods_ng_xml.origin_info.dateCaptured.to_a)
+        result
+      end
+
+      # return a single string intended for lexical sorting 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 lexical sorting
+      #   note that for string sorting  5 B.C. = -5  => -995;  6 B.C. => -994  so 6 B.C. sorts before 5 B.C.
+      def pub_date_sortable_string(ignore_approximate = false)
+        # prefer dateIssued
+        result = pub_date_best_sort_str_value(date_issued_elements(ignore_approximate))
+        result ||= pub_date_best_sort_str_value(date_created_elements(ignore_approximate))
+        # dateCaptured for web archive seed records
+        result ||= pub_date_best_sort_str_value(@mods_ng_xml.origin_info.dateCaptured.to_a)
+        result
+      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 pub_date_best_single_facet_value(date_el_array)
+        return if date_el_array.empty?
+        # prefer keyDate
+        key_date_el = self.class.keyDate(date_el_array)
+        result = DateParsing.facet_string_from_date_str(key_date_el.content) if key_date_el
+        return result if result
+        # settle for earliest parseable date
+        _ignore, orig_str_to_parse = self.class.earliest_date(date_el_array)
+        DateParsing.facet_string_from_date_str(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;
+      #    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 lexical sorting
+      def pub_date_best_sort_str_value(date_el_array)
+        return if date_el_array.empty?
+        # prefer keyDate
+        key_date_el = self.class.keyDate(date_el_array)
+        result = DateParsing.sortable_year_string_from_date_str(key_date_el.content) if key_date_el
+        return result if result
+        # settle for earliest parseable date
+        sortable_str, _ignore = self.class.earliest_date(date_el_array)
+        sortable_str if sortable_str
+      end
+
+      protected :pub_date_best_single_facet_value, :pub_date_best_sort_str_value
+
+      # return /originInfo/dateCreated elements in MODS records
+      # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
+      #   should be excluded; false approximate dates should be included
+      # @return [Array<Nokogiri::XML::Element>]
+      def date_created_elements(ignore_approximate=false)
+        date_created_nodeset = @mods_ng_xml.origin_info.dateCreated
+        return self.class.remove_approximate(date_created_nodeset) if ignore_approximate
+        date_created_nodeset.to_a
+      end
+
+      # return /originInfo/dateIssued elements in MODS records
+      # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
+      #   should be excluded; false approximate dates should be included
+      # @return [Array<Nokogiri::XML::Element>]
+      def date_issued_elements(ignore_approximate=false)
+        date_issued_nodeset = @mods_ng_xml.origin_info.dateIssued
+        return self.class.remove_approximate(date_issued_nodeset) if ignore_approximate
+        date_issued_nodeset.to_a
+      end
+
+      # given a set of date elements, return the single element with attribute keyDate="yes"
+      #  or return nil if no elements have attribute keyDate="yes", or if multiple elements have keyDate="yes"
+      # @param [Array<Nokogiri::XML::Element>] Array of date elements
+      # @return [Nokogiri::XML::Element, nil] single date element with attribute keyDate="yes", or nil
+      def self.keyDate(elements)
+        keyDates = elements.select { |node| node["keyDate"] == 'yes' }
+        keyDates.first if keyDates.size == 1
+      end
+
+      # remove Elements from NodeSet if they have a qualifier attribute of 'approximate' or 'questionable'
+      # @param [Nokogiri::XML::NodeSet<Nokogiri::XML::Element>] nodeset set of date elements
+      # @return [Array<Nokogiri::XML::Element>] the set of date elements minus any that
+      #   had a qualifier attribute of 'approximate' or 'questionable'
+      def self.remove_approximate(nodeset)
+        nodeset.select { |node| node unless date_is_approximate?(node) }
+      end
+
+      # NOTE: legal values for MODS date elements with attribute qualifier are
+      #   'approximate', 'inferred' or 'questionable'
+      # @param [Nokogiri::XML::Element] date_element MODS date element
+      # @return [Boolean] true if date_element has a qualifier attribute of "approximate" or "questionable",
+      #   false if no qualifier attribute, or if attribute is 'inferred' or some other value
+      def self.date_is_approximate?(date_element)
+        qualifier = date_element["qualifier"] if date_element.respond_to?('[]')
+        qualifier == 'approximate' || qualifier == 'questionable'
+      end
+
+      # get earliest parseable date from the passed date elements
+      # @param [Array<Nokogiri::XML::Element>] date_el_array the elements from which to select a pub date
+      # @return two String values:
+      #   the first is the lexically sortable String value of the earliest date;
+      #   the second is the original String value of the chosen element
+      def self.earliest_date(date_el_array)
+        poss_results = {}
+        date_el_array.each { |el|
+          result = DateParsing.sortable_year_string_from_date_str(el.content)
+          poss_results[result] = el.content if result
+        }
+        earliest = poss_results.keys.sort.first if poss_results.present?
+        return earliest, poss_results[earliest] if earliest
+      end
+
+
+# ----   old date parsing methods used downstream of gem;  will be deprecated/replaced with new date parsing methods
+
+      def place
+        vals = self.term_values([:origin_info, :place, :placeTerm])
+        vals
+      end
+
+      # For the date display only, the first place to look is in the dates without encoding=marc array.
+      # If no such dates, select the first date in the dates_marc_encoding array.  Otherwise return nil
+      # @return [String] value for the pub_date_display Solr field for this document or nil if none
+      def pub_date_display
+        return dates_no_marc_encoding.first unless dates_no_marc_encoding.empty?
+        return dates_marc_encoding.first unless dates_marc_encoding.empty?
+        nil
+      end
+
+      # For the date indexing, sorting and faceting, the first place to look is in the dates with encoding=marc array.
+      # If that doesn't exist, look in the dates without encoding=marc array.  Otherwise return nil
+      # @return [Array<String>] values for the date Solr field for this document or nil if none
+      def pub_dates
+        return dates_marc_encoding unless dates_marc_encoding.empty?
+        return dates_no_marc_encoding unless dates_no_marc_encoding.empty?
+        nil
+      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
+          return nil if @pub_year == ''
+          return @pub_year
+        end
+
+        dates = pub_dates
+        if dates
+          pruned_dates = []
+          dates.each do |f_date|
+            # remove ? and []
+            if f_date.length == 4 && f_date.end_with?('?')
+              pruned_dates << f_date.tr('?', '0')
+            else
+              pruned_dates << f_date.delete('?[]')
+            end
+          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
+          # Check for years in u notation, e.g., 198u
+          @pub_year = get_u_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_bc_year 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 = ''
+        nil
+      end
+
+      # creates a date suitable for sorting. Guarnteed to be 4 digits or nil
+      def pub_date_sort
+        if pub_date
+          pd = pub_date
+          pd = '0' + pd if pd.length == 3
+          pd = pd.gsub('--', '00')
+        end
+        fail "pub_date_sort was about to return a non 4 digit value #{pd}!" if pd && 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
+        pub_year || 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.start_with?('-')
+            return (pub_date.to_i + 1000).to_s + ' B.C.'
+          end
+          if pub_date.include? '--'
+            cent = pub_date[0, 2].to_i
+            cent += 1
+            cent = cent.to_s + 'th century'
+            return cent
+          else
+            return pub_date
+          end
+        end
+        nil
+      end
+
+# ----   old date parsing methods will be deprecated/replaced with new date parsing methods
+
+    protected
+
+      # @return [Array<String>] dates from dateIssued and dateCreated tags from origin_info with encoding="marc"
+      def dates_marc_encoding
+        @dates_marc_encoding ||= begin
+          parse_dates_from_originInfo
+          @dates_marc_encoding
+        end
+      end
+
+      # @return [Array<String>] dates from dateIssued and dateCreated tags from origin_info with encoding not "marc"
+      def dates_no_marc_encoding
+        @dates_no_marc_encoding ||= begin
+          parse_dates_from_originInfo
+          @dates_no_marc_encoding
+        end
+      end
+
+      # Populate @dates_marc_encoding and @dates_no_marc_encoding from dateIssued and dateCreated tags from origin_info
+      # with and without encoding=marc
+      def parse_dates_from_originInfo
+        @dates_marc_encoding = []
+        @dates_no_marc_encoding = []
+        self.origin_info.dateIssued.each { |di|
+          if di.encoding == "marc"
+            @dates_marc_encoding << di.text
+          else
+            @dates_no_marc_encoding << di.text
+          end
+        }
+        self.origin_info.dateCreated.each { |dc|
+          if dc.encoding == "marc"
+            @dates_marc_encoding << dc.text
+          else
+            @dates_no_marc_encoding << dc.text
+          end
+        }
+      end
+
+
+      def is_number?(object)
+        true if Integer(object) rescue false
+      end
+
+      def is_date?(object)
+        true if Date.parse(object) rescue false
+      end
+
+      # TODO:  need tests for these methods
+
+      # get a 4 digit year like 1865 from array of dates
+      # @param [Array<String>] dates an array of potential year strings
+      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
+            # when there are multiple matches, 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
+            return matches.first
+          end
+        end
+        nil
+      end
+
+      # get a 3 digit year like 965 from the date array
+      # @param [Array<String>] dates an array of potential year strings
+      def get_three_digit_year(dates)
+        dates.each do |f_date|
+          matches = f_date.scan(/\d{3}/)
+          return matches.first if matches.length > 0
+        end
+        nil
+      end
+
+      # get the 3 digit BC year, return it as a negative, so -700 for 300 BC.
+      #  Other methods will translate it to proper display, this is good for sorting.
+      # @param [Array<String>] dates an array of potential year strings
+      def get_bc_year(dates)
+        dates.each do |f_date|
+          matches = f_date.scan(/\d{3} B.C./)
+          if matches.length > 0
+            bc_year = matches.first[0..2]
+            return (bc_year.to_i - 1000).to_s
+          end
+        end
+        nil
+      end
+
+      # get a single digit century like '9th century' from the date array
+      # @param [Array<String>] dates an array of potential year strings
+      # @return [String] y--  if we identify century digit in string
+      def get_single_digit_century(dates)
+        dates.each do |f_date|
+          matches = f_date.scan(/\d{1}th/)
+          next if matches.length == 0
+          if matches.length == 1
+            @pub_year = ((matches.first[0, 2].to_i) - 1).to_s + '--'
+            return @pub_year
+          else
+            # when there are multiple matches, check for ones with CE after them
+            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') || pos > 0
+                @pub_year = ((match[0, 1].to_i) - 1).to_s + '--'
+                return @pub_year
+              end
+            end
+          end
+        end
+        nil
+      end
+
+      # get a double digit century like '12th century' from the date array
+      # @param [Array<String>] dates an array of potential year strings
+      # @return [String] yy--  if we identify century digits in string
+      def get_double_digit_century(dates)
+        dates.each do |f_date|
+          matches = f_date.scan(/\d{2}th/)
+          next if matches.length == 0
+          if matches.length == 1
+            @pub_year=((matches.first[0, 2].to_i) - 1).to_s + '--'
+            return @pub_year
+          else
+            # when there are multiple matches, check for ones with CE after them
+            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
+        nil
+      end
+
+      # If a year has a "u" in it, replace u with 0 for yyyu (becomes yyy0)
+      #   and replace u with '-' for yyuu  (becomes yy--)
+      # @param [String] dates looking for matches on yyyu or yyuu in these strings
+      # @return [String, nil] String of format yyy0 or yy--, or nil
+      def get_u_year(dates)
+        dates.each do |f_date|
+          # Single digit u notation
+          matches = f_date.scan(/\d{3}u/)
+          return matches.first.tr('u', '0') if matches.length == 1
+          # Double digit u notation
+          matches = f_date.scan(/\d{2}u{2}/)
+          return matches.first.tr('u', '-') if matches.length == 1
+        end
+        nil
+      end
+    end # class Record
+  end
+end