stanford-mods 1.3.4 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ea1bae95a44c285bf8594fa40a73c2aa0b328d1
-  data.tar.gz: 479f7c52ae3c7c29592a870a819e10e6e1abb692
+  metadata.gz: 77f36520f38dfd83cd8cc79480fc5fbda45b2df6
+  data.tar.gz: b1e7a4db9be39cdbeeca3124a62e3c0403ba31a2
 SHA512:
-  metadata.gz: b6f535642244577ecfb2f7cc2d4b4291c9a7cb052869543cf989f6cce72cb5b8609e668e4ace238940c2c252b8613e63908b6627aef608b5e716068b52de23f5
-  data.tar.gz: 97db3a6affbc9e74b62432961d712ace6f860cbf77b36137f22287f2e3c4f491d5cbfeeb24a540bd7c48ed21e38e91663d0dd9436e2cc62e7835bc50bd319a11
+  metadata.gz: fd0ab891b9f578611b928231dcf45debcffc209068032fdbcd98d93ada56e95fc5afa82be97dfc163287297e190ff1ef258abef27dcd58170ec18152381da398
+  data.tar.gz: f604d45d319fbce30215ff436ad62ebc23a0bab11d995d6599bef137dae9a5465344d69d2492d84b29436711106ae7e80ce9090cb3005c3be4fe1fb004b58b7e

data/lib/stanford-mods/date_parsing.rb

@@ -12,7 +12,14 @@ module Stanford
       # @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
+        DateParsing.new(date_str).facet_string_from_date_str
+      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
       end
 
       # get String sortable value year if we can parse date_str to get a year.
@@ -22,7 +29,7 @@ module Stanford
       # @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
+        DateParsing.new(date_str).sortable_year_string_from_date_str
       end
 
       # true if the year is between -999 and (current year + 1)
@@ -33,6 +40,13 @@ module Stanford
         (-1000 < year_str.to_i) && (year_str.to_i < Date.today.year + 2)
       end
 
+      # true if the year is between -9999 and (current year + 1)
+      # @return [Boolean] true if the year is between -9999 and (current year + 1); false otherwise
+      def self.year_int_valid?(year)
+        return false unless year.is_a? Integer
+        (-1000 < year.to_i) && (year < Date.today.year + 2)
+      end
+
       attr_reader :orig_date_str
 
       def initialize(date_str)
@@ -48,18 +62,11 @@ 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 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
+        result = sortable_year_for_yyyy_yy_or_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
+          no_brackets = remove_brackets
+          return DateParsing.new(no_brackets).facet_string_from_date_str if no_brackets
         end
         # parsing below this line gives string inapprop for year_str_valid?
         unless self.class.year_str_valid?(result)
@@ -71,6 +78,23 @@ module Stanford
         result
       end
 
+      # get Integer year if we can parse date_str to get a year.
+      # @return [Integer, nil] Integer year if we could parse one, nil otherwise
+      def year_int_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_int_for_bc if orig_date_str.match(BC_REGEX)
+        result = sortable_year_for_yyyy_yy_or_decade
+        result ||= sortable_year_for_century
+        result ||= sortable_year_int_for_early_numeric
+        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).year_int_from_date_str if no_brackets
+        end
+        result.to_i if result && self.class.year_int_valid?(result.to_i)
+      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
@@ -79,28 +103,39 @@ module Stanford
       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
+        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_century
-        result ||= sortable_year_for_early_numeric
+        result ||= sortable_year_str_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
+          no_brackets = remove_brackets
+          return DateParsing.new(no_brackets).sortable_year_string_from_date_str if no_brackets
         end
         result if self.class.year_str_valid?(result)
       end
 
+      # 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
+        # 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
+
+      # removes brackets between digits such as 169[5] or [18]91
+      def remove_brackets
+        orig_date_str.delete('[]') if orig_date_str.match(BRACKETS_BETWEEN_DIGITS_REXEXP)
+      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
+        matches.to_s if matches
       end
 
       # returns 4 digit year as String if we have a x/x/yy or x-x-yy pattern
@@ -131,10 +166,8 @@ module Stanford
       # @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
+        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
 
       CENTURY_WORD_REGEXP = Regexp.new('(\d{1,2}).*century')
@@ -177,22 +210,29 @@ module Stanford
 
       BC_REGEX = Regexp.new('(\d{1,4}).*' + Regexp.escape('B.C.'))
 
-      # get String sortable value for B.C. if we have  B.C. pattern
+      # 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
+      def sortable_year_str_for_bc
+        bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
+        ($1.to_i - 1000).to_s if bc_matches
+      end
+
+      # get Integer sortable value for B.C. if we have B.C. pattern
+      # @return [Integer, nil] Integer sortable -ddd if B.C. in pattern; nil otherwise
+      def sortable_year_int_for_bc
         bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
-        return ($1.to_i - 1000).to_s if bc_matches
+        "-#{$1}".to_i 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
+        bc_matches.to_s if bc_matches
       end
 
       EARLY_NUMERIC = Regexp.new('^\-?\d{1,3}$')
@@ -203,7 +243,7 @@ module Stanford
       #  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
+      def sortable_year_str_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
@@ -214,6 +254,13 @@ module Stanford
         end
       end
 
+      # get Integer sortable value from date String containing yyy, yy, y, -y, -yy, -yyy, -yyyy
+      # @return [Integer, nil] Integer sortable -ddd if orig_date_str matches pattern; nil otherwise
+      def sortable_year_int_for_early_numeric
+        return orig_date_str.to_i if orig_date_str.match(EARLY_NUMERIC)
+        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
       #   negative number strings will be changed to B.C. strings
       def facet_string_for_early_numeric
@@ -239,7 +286,6 @@ module Stanford
       rescue ArgumentError
         nil # explicitly want nil if date won't parse
       end
-
     end
   end
-end
+end

data/lib/stanford-mods/origin_info.rb

@@ -19,12 +19,18 @@ module Stanford
       #   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
+        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
+      # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
+      #   should be ignored; false if approximate dates should be included
+      # @return [Integer] publication year as an Integer
+      #   note that for sorting  5 B.C. => -5;  666 B.C. => -666
+      def pub_year_int(ignore_approximate = false)
+        single_pub_year(ignore_approximate, :year_int)
       end
 
       # return a single string intended for lexical sorting for pub date
@@ -34,47 +40,44 @@ module Stanford
       #   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
+      # @deprecated  use pub_year_int
+      def pub_year_sort_str(ignore_approximate = false)
+        single_pub_year(ignore_approximate, :year_sort_str)
       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
+      def year_facet_str(date_el_array)
+        result = date_parsing_result(date_el_array, :facet_string_from_date_str)
         return result if result
-        # settle for earliest parseable date
-        _ignore, orig_str_to_parse = self.class.earliest_date(date_el_array)
+        _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
       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 [Integer] publication year as an Integer
+      def year_int(date_el_array)
+        result = date_parsing_result(date_el_array, :year_int_from_date_str)
+        return result if result
+        year_int, _ignore = self.class.earliest_year_int(date_el_array)
+        year_int if year_int
+      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
+      def year_sort_str(date_el_array)
+        result = date_parsing_result(date_el_array, :sortable_year_string_from_date_str)
         return result if result
-        # settle for earliest parseable date
-        sortable_str, _ignore = self.class.earliest_date(date_el_array)
+        sortable_str, _ignore = self.class.earliest_year_str(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
@@ -122,19 +125,71 @@ module Stanford
         qualifier == 'approximate' || qualifier == 'questionable'
       end
 
-      # get earliest parseable date from the passed date elements
+      # get earliest parseable year (as an Integer) 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 first is the Integer value of the earliest year;
       #   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
+      def self.earliest_year_int(date_el_array)
+        earliest_year(date_el_array, :year_int_from_date_str)
+      end
+
+      # get earliest parseable year (as a String) 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 year;
+      #   the second is the original String value of the chosen element
+      def self.earliest_year_str(date_el_array)
+        earliest_year(date_el_array, :sortable_year_string_from_date_str)
+      end
+
+      # return a single value intended for pub date flavor indicated by method_sym
+      # 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
+      # @param [Symbol] method_sym method name in DateParsing, as a symbol
+      # @return [String, Integer] publication year as String or Integer
+      def single_pub_year(ignore_approximate, method_sym)
+        result = send(method_sym, date_issued_elements(ignore_approximate))
+        result ||= send(method_sym, date_created_elements(ignore_approximate))
+        # dateCaptured for web archive seed records
+        result ||= send(method_sym, @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
+      # @param [Symbol] method_sym method name in DateParsing, as a symbol
+      # @return [Integer, String] year as a String or Integer, depending on method_sym
+      def date_parsing_result(date_el_array, method_sym)
+        return if date_el_array.empty?
+        # prefer keyDate
+        key_date_el = self.class.keyDate(date_el_array)
+        DateParsing.send(method_sym, key_date_el.content) if key_date_el
+      end
+      # temporarily use this technique to mark methods private until we get rid of old date parsing methods below
+      private :single_pub_year, :date_parsing_result
+
+      class << self
+        private
+        # get earliest parseable year from the passed date elements
+        # @param [Array<Nokogiri::XML::Element>] date_el_array the elements from which to select a pub date
+        # @param [Symbol] method_sym method name in DateParsing, as a symbol
+        # @return two values:
+        #   the first is either:  the lexically sortable String value of the earliest date or the Integer value of same,
+        #     depending on the method_sym passed in
+        #   the second is the original String value of the chosen element
+        def earliest_year(date_el_array, method_sym)
+          poss_results = {}
+          date_el_array.each { |el|
+            result = DateParsing.send(method_sym, 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
       end
 
 
@@ -145,25 +200,58 @@ module Stanford
         vals
       end
 
+      # Values for the pub date facet. This is less strict than the 4 year date requirements for pub_date
+      # Jan 2016:  used to populate Solr pub_date field for Spotlight and SearchWorks
+      #   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
+      # @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
+
+      # creates a date suitable for sorting. Guarnteed to be 4 digits or nil
+      # @deprecated:  use pub_year_int, or pub_year_sort_str if you must have a string (why?)
+      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
+
       # 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
+      # @deprecated:  DO NOT USE: this is no longer used in SW, Revs or Spotlight Jan 2016
       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
+# ----   old date parsing protected methods will be deprecated/replaced with new date parsing methods (see also DateParsing)
+
+    protected
 
-      # Get the publish year from mods
+      # The year the object was published
       # @return [String] 4 character year or nil if no valid date was found
       def pub_year
         # use the cached year if there is one
@@ -201,47 +289,17 @@ module Stanford
         @pub_year = ''
         nil
       end
+      alias_method :pub_date, :pub_year
 
-      # 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
+      # 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
 
-# ----   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
@@ -279,7 +337,6 @@ module Stanford
         }
       end
 
-
       def is_number?(object)
         true if Integer(object) rescue false
       end
@@ -288,8 +345,6 @@ module Stanford
         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)