parse_date 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 446afc4299ca93634d6689b20d3a32bdb28460da5627701682733e18bb1f0a16
-  data.tar.gz: b5f6bbceab8542cc3c977c1c1ea8a4e250f82a9ae3a1eed2b335050067145703
+  metadata.gz: 3927636e715e52bf2f38a8c0f3f384b06dc29971000c4b700a5e9f8a128c144b
+  data.tar.gz: 1f6b9fcb0f3bbf37f5d8417ee21c92ee19c87604394453dbe60a4f16b722e59c
 SHA512:
-  metadata.gz: 052f5d35a64c52f5bd74af2e487b70c8b03c37252cce33554aa3e7d6ba8141d9f0edd7c719aa487dbddb2e465b76d2d1ab222f057e68c7e6fa322eef313a35e6
-  data.tar.gz: 880e66962d42d0c3f2824510a94edcf9256cc6ba8298815721a2a720e8f9ef2158793820ff71fc3a22a0ad0f3397db3f8e2361753ee661494ed1371117562eb7
+  metadata.gz: c8d350764a5d813e5daa7e5abc0b17d9167b81b249322b52f181e7ea5ccba58f468883f30f6bdbd91e3a43f4da03270cd62581ea2e23ae5ac2a45261ecdf5e24
+  data.tar.gz: 6e421ee0b10f44f2cee021dc198cddb74a8640639b7c66ccb74f515ae891c4be6cadd47d6b5b12af1f4a9d6f3698f1fc3fe224c6be5aed03ce98eb5376c15d8f

data/.rubocop.yml

@@ -13,7 +13,14 @@ Metrics/LineLength:
   Max: 120
 
 Metrics/MethodLength:
-  Max: 15
+  Max: 22
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  Exclude:
+    - spec/**/*
 
 Style/WordArray:
   Enabled: false

data/.rubocop_todo.yml

@@ -1,34 +1,33 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2019-10-09 15:35:45 -0700 using RuboCop version 0.74.0.
+# on 2019-10-21 14:32:14 -0700 using RuboCop version 0.74.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 2
-# Cop supports --auto-correct.
-Lint/StringConversionInInterpolation:
-  Exclude:
-    - 'lib/parse_date/int_from_string.rb'
-
-# Offense count: 3
+# Offense count: 5
 Metrics/AbcSize:
-  Max: 18
+  Max: 37
 
-# Offense count: 4
+# Offense count: 8
 # Configuration parameters: CountComments, ExcludedMethods.
 # ExcludedMethods: refine
 Metrics/BlockLength:
-  Max: 561
+  Max: 812
 
-# Offense count: 3
+# Offense count: 4
 Metrics/CyclomaticComplexity:
-  Max: 8
+  Max: 12
 
 # Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ModuleLength:
+  Max: 168
+
+# Offense count: 4
 Metrics/PerceivedComplexity:
-  Max: 9
+  Max: 12
 
 # Offense count: 2
 Style/Documentation:
@@ -53,18 +52,11 @@ Style/RegexpLiteral:
   Exclude:
     - 'lib/parse_date/int_from_string.rb'
 
-# Offense count: 1
+# Offense count: 3
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyleForMultiline.
 # SupportedStylesForMultiline: comma, consistent_comma, no_comma
 Style/TrailingCommaInArrayLiteral:
   Exclude:
     - 'spec/parse_date/int_from_string_spec.rb'
-
-# Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, no_comma
-Style/TrailingCommaInHashLiteral:
-  Exclude:
-    - 'spec/parse_date/int_from_string_spec.rb'
+    - 'spec/parse_date_spec.rb'

data/README.md

@@ -30,40 +30,127 @@ ParseDate has class methods for date string parsing.
 ```
 require 'parse_date'
 
-ParseDate.earliest_year('12/25/00') # 2000
-ParseDate.earliest_year('5-1-21') # 1921
-ParseDate.earliest_year('1666 B.C.') # -1666
-ParseDate.earliest_year('-914') # -914
-ParseDate.earliest_year('[c1926]') # 1926
-ParseDate.earliest_year('ca. 1558') # 1558
-ParseDate.earliest_year('195-') # 1950
-ParseDate.earliest_year('199u') # 1990
-ParseDate.earliest_year('197?') # 1970
-ParseDate.earliest_year('196x') # 1960
-ParseDate.earliest_year('18th century CE') # 1700
-ParseDate.earliest_year('17uu') # 1700
-
-ParseDate.latest_year('195-') # 1959
-ParseDate.latest_year('199u') # 1999
-ParseDate.latest_year('197?') # 1979
-ParseDate.latest_year('196x') # 1969
-ParseDate.latest_year('18th century CE') # 1799
-ParseDate.latest_year('17uu') # 1799
-
-ParseDate.year_int_valid?(0) # true
-ParseDate.year_int_valid?(5) # true
-ParseDate.year_int_valid?(33) # true
-ParseDate.year_int_valid?(150) # true
-ParseDate.year_int_valid?(2019) # true
-ParseDate.year_int_valid?(Date.today.year + 1) # true
-ParseDate.year_int_valid?(-3) # true
-ParseDate.year_int_valid?(-35) # true
-ParseDate.year_int_valid?(-999) # true
-ParseDate.year_int_valid?(-1666) # false - four digit negative years not considered valid here
-ParseDate.year_int_valid?(165x) # false
-ParseDate.year_int_valid?(198-) # false
-ParseDate.year_int_valid?('random text') # false
-ParseDate.year_int_valid?(nil) # false
+ParseDate.parse_range('12/25/00')                       # [2000]
+ParseDate.parse_range('5-1-25')                         # [1925]
+ParseDate.parse_range('1666 B.C.')                      # [-1666]
+ParseDate.parse_range('-914')                           # [-914]
+ParseDate.parse_range('[c1926]')                        # [1926]
+ParseDate.parse_range('ca. 1558')                       # [1558]
+ParseDate.parse_range('195-')                           # (1950..1959).to_a
+ParseDate.parse_range('199u')                           # (1990..1999).to_a
+ParseDate.parse_range('197?')                           # (1970..1979).to_a
+ParseDate.parse_range('196x')                           # (1960..1969).to_a
+ParseDate.parse_range('18th century CE')                # (1700..1799).to_a
+ParseDate.parse_range('17uu')                           # (1700..1799).to_a
+ParseDate.parse_range('between 1694 and 1799')          # (1694..1799).to_a
+ParseDate.parse_range('between 1 and 5')                # (1..5).to_a
+ParseDate.parse_range('between 300 and 150 B.C.')       # (-300..-150).to_a
+ParseDate.parse_range('-5 - 3')                         # (-5..3).to_a
+ParseDate.parse_range('1496-1499')                      # (1496..1499).to_a
+ParseDate.parse_range('1750?-1867')                     # (1750..1867).to_a
+ParseDate.parse_range('17--?-18--?')                    # (1700..1899).to_a
+ParseDate.parse_range('1835 or 1836')                   # [1835, 1836]
+ParseDate.parse_range('17-- or 18--?')                  # (1700..1899).to_a
+ParseDate.parse_range('-2 or 1?')                       # (-2..1).to_a
+ParseDate.parse_range('17th or 18th century?')          # (1600..1799).to_a
+ParseDate.parse_range('ca. 5th–6th century A.D.')       # (400..599).to_a
+ParseDate.parse_range('ca. 9th–8th century B.C.')       # (-999..-800).to_a
+ParseDate.parse_range('ca. 13th–12th century B.C.')     # (-1399..-1200).to_a
+ParseDate.parse_range('5th century B.C.')               # (-599..-500).to_a
+ParseDate.parse_range('1975 - 1905')                    # last year > first year, raises error
+ParseDate.parse_range('-100 - -150')                    # last year > first year, raises error
+ParseDate.parse_range('1975 or 1905')                   # last year > first year, raises error
+ParseDate.parse_range('2050')                           # year later than current year + 1, raises error
+ParseDate.parse_range('12345')                          # year later than current year + 1, raises error
+ParseDate.parse_range('random text')                    # can't parse years, raises error
+ParseDate.parse_range(nil)                              # can't parse years, raises error
+
+ParseDate.earliest_year('12/25/00')                     # 2000
+ParseDate.earliest_year('5-1-21')                       # 1921
+ParseDate.earliest_year('1666 B.C.')                    # -1666
+ParseDate.earliest_year('-914')                         # -914
+ParseDate.earliest_year('[c1926]')                      # 1926
+ParseDate.earliest_year('ca. 1558')                     # 1558
+ParseDate.earliest_year('195-')                         # 1950
+ParseDate.earliest_year('199u')                         # 1990
+ParseDate.earliest_year('197?')                         # 1970
+ParseDate.earliest_year('196x')                         # 1960
+ParseDate.earliest_year('18th century CE')              # 1700
+ParseDate.earliest_year('17uu')                         # 1700
+ParseDate.earliest_year('between 1694 and 1799')        # 1694
+ParseDate.earliest_year('between 1 and 5')              # 1
+ParseDate.earliest_year('between 300 and 150 B.C.')     # -300
+ParseDate.earliest_year('1496-1499')                    # 1496
+ParseDate.earliest_year('1750?-1867')                   # 1750
+ParseDate.earliest_year('17--?-18--?')                  # 1700
+ParseDate.earliest_year('1835 or 1836')                 # 1835
+ParseDate.earliest_year('17-- or 18--?')                # 1700
+ParseDate.earliest_year('17th or 18th century?')        # 1600
+ParseDate.earliest_year('ca. 5th–6th century A.D.')     # 400
+ParseDate.earliest_year('ca. 9th–8th century B.C.')     # -999
+ParseDate.earliest_year('ca. 13th–12th century B.C.')   # -1399
+ParseDate.earliest_year('5th century B.C.')             # -599
+
+ParseDate.latest_year('195-')                           # 1959
+ParseDate.latest_year('199u')                           # 1999
+ParseDate.latest_year('197?')                           # 1979
+ParseDate.latest_year('196x')                           # 1969
+ParseDate.latest_year('18th century CE')                # 1799
+ParseDate.latest_year('17uu')                           # 1799
+ParseDate.latest_year('between 1694 and 1799')          # 1799
+ParseDate.latest_year('between 1 and 5')                # 5
+ParseDate.latest_year('between 300 and 150 B.C.')       # -150
+ParseDate.latest_year('1496-1499')                      # 1499
+ParseDate.latest_year('1750?-1867')                     # 1867
+ParseDate.latest_year('17--?-18--?')                    # 1899
+ParseDate.latest_year('1757-58')                        # 1758
+ParseDate.latest_year('1975-05')                        # 1975 (range invalid)
+ParseDate.latest_year('1835 or 1836')                   # 1836
+ParseDate.latest_year('17-- or 18--?')                  # 1899
+ParseDate.latest_year('17th or 18th century?')          # 1799
+ParseDate.latest_year('ca. 5th–6th century A.D.')       # 599
+ParseDate.latest_year('ca. 9th–8th century B.C.')       # -800
+ParseDate.latest_year('ca. 13th–12th century B.C.')     # -1200
+ParseDate.latest_year('5th century B.C.')               # -500
+ParseDate.latest_year('-5 - 3')                         # 3,
+
+ParseDate.range_array('1993', '1995')                   # [1993, 1994, 1995]
+ParseDate.range_array(1993, 1995)                       # [1993, 1994, 1995]
+ParseDate.range_array(0, '0001')                        # [0, 1]
+ParseDate.range_array('-0003', '0000')                  # [-3, -2, -1, 0]
+ParseDate.range_array(-1, 1)                            # [-1, 0, 1]
+ParseDate.range_array(15, 15)                           # [15]
+ParseDate.range_array(-100, '-99')                      # [-100, -99]
+ParseDate.range_array('98', 101)                        # [98, 99, 100, 101]
+ParseDate.range_array('word1', 'word2')                 # throws ArgumentError
+ParseDate.range_array('1993', 1990)                     # throws StandardError - bad range
+ParseDate.range_array('12345', 12345)                   # throws StandardError - bad range
+
+ParseDate.year_range_valid?(1975, 1905)                 # false, first year > last year
+ParseDate.year_range_valid?(-100, -150)                 # false, first year > last year
+ParseDate.year_range_valid?(2050, 2070)                 # false, year later than current year + 1
+ParseDate.year_range_valid?(2007, 2050)                 # false, year later than current year + 1
+ParseDate.year_range_valid?(2007, 2009)                 # true
+ParseDate.year_range_valid?(75, 150)                    # true
+ParseDate.year_range_valid?(-3, 2)                      # true
+ParseDate.year_range_valid?(-100, -50)                  # true
+ParseDate.year_range_valid?(-1500, -1499)               # true
+ParseDate.year_range_valid?(-15000, -14999)             # true
+
+ParseDate.year_int_valid?(0)                            # true
+ParseDate.year_int_valid?(5)                            # true
+ParseDate.year_int_valid?(33)                           # true
+ParseDate.year_int_valid?(150)                          # true
+ParseDate.year_int_valid?(2019)                         # true
+ParseDate.year_int_valid?(Date.today.year + 1)          # true
+ParseDate.year_int_valid?(-3)                           # true
+ParseDate.year_int_valid?(-35)                          # true
+ParseDate.year_int_valid?(-999)                         # true
+ParseDate.year_int_valid?(-1666)                        # false - four digit negative years not considered valid here
+ParseDate.year_int_valid?(165x)                         # false
+ParseDate.year_int_valid?(198-)                         # false
+ParseDate.year_int_valid?('random text')                # false
+ParseDate.year_int_valid?(nil)                          # false
 ```
 
 ## Development

data/lib/parse_date.rb

@@ -26,15 +26,54 @@ class ParseDate
   extend ParseDate::IntFromString
 
   # class method delegation
-  def self.earliest_year(orig_date_str)
-    ParseDate::IntFromString.earliest_year(orig_date_str)
+  def self.earliest_year(date_str)
+    ParseDate::IntFromString.earliest_year(date_str)
   end
 
-  def self.latest_year(orig_date_str)
-    ParseDate::IntFromString.latest_year(orig_date_str)
+  def self.latest_year(date_str)
+    ParseDate::IntFromString.latest_year(date_str)
   end
 
-  def self.year_int_valid?(orig_date_str)
-    ParseDate::IntFromString.year_int_valid?(orig_date_str)
+  def self.year_int_valid?(date_str)
+    ParseDate::IntFromString.year_int_valid?(date_str)
+  end
+
+  # @return [Array] array of Integer year values from earliest year to latest year, inclusive
+  def self.parse_range(date_str)
+    first = earliest_year(date_str)
+    last = latest_year(date_str)
+    raise ParseDate::Error, "Unable to parse range from '#{date_str}'" unless year_range_valid?(first, last)
+
+    range_array(first, last)
+  rescue StandardError => e
+    raise ParseDate::Error, "Unable to parse range from '#{date_str}': #{e.message}"
+  end
+
+  # true if:
+  #   both years are not newer than (current year + 1)
+  #   first_year <= last_year
+  # false otherwise
+  def self.year_range_valid?(first_year, last_year)
+    upper_bound = Date.today.year + 2
+    return false if first_year > upper_bound || last_year > upper_bound
+    return false if first_year > last_year
+
+    true
+  end
+
+  # @param [Integer, String] first_year, expecting integer or parseable string for .to_i
+  # @param [Integer, String] last_year, expecting integer or parseable string for .to_i
+  # @return [Array] array of Integer year values from first to last, inclusive
+  def self.range_array(first_year, last_year)
+    first_year = first_year.to_i if first_year.is_a?(String) && first_year.match?(/^-?\d+$/)
+    last_year = last_year.to_i if last_year.is_a?(String) && last_year.match?(/^-?\d+$/)
+
+    return [] unless last_year || first_year
+    return [first_year] if last_year.nil? && first_year
+    return [last_year] if first_year.nil? && last_year
+    raise(StandardError, "unable to create year range array from #{first_year}, #{last_year}") unless
+      year_range_valid?(first_year, last_year)
+
+    Range.new(first_year, last_year).to_a
   end
 end

data/lib/parse_date/int_from_string.rb

@@ -7,7 +7,7 @@ class ParseDate
   # Parse (Year) Integers from Date Strings
   module IntFromString
 
-    # earliest year as Integer if we can parse one from orig_date_str
+    # earliest year as Integer if we can parse one from date_str
     #  e.g. if 17uu, result is 1700
     # NOTE:  if we have a x/x/yy or x-x-yy pattern (the only 2 digit year patterns
     #   found in our actual date strings in stanford-mods records), then
@@ -15,25 +15,30 @@ class ParseDate
     #   1/1/17  ->  2017
     #   1/1/27  ->  1927
     # @return [Integer, nil] Integer year if we could parse one, nil otherwise
-    def self.earliest_year(orig_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 ParseDate.send(:year_int_for_bc, orig_date_str) if orig_date_str.match(BC_REGEX)
-
-      result = ParseDate.send(:first_four_digits, orig_date_str)
-      result ||= ParseDate.send(:year_from_mm_dd_yy, orig_date_str)
-      result ||= ParseDate.send(:first_year_for_decade, orig_date_str) # 19xx or 20xx
-      result ||= ParseDate.send(:first_year_for_century, orig_date_str)
-      result ||= ParseDate.send(:year_for_early_numeric, orig_date_str)
+    def self.earliest_year(date_str)
+      return unless date_str && !date_str.empty?
+      return if date_str == '0000-00-00' # shpc collection has these useless dates
+
+      # B.C. first (match longest string first)
+      return ParseDate.send(:earliest_century_bc, date_str) if date_str.match(YY_YY_CENTURY_BC_REGEX)
+      return ParseDate.send(:between_bc_earliest_year, date_str) if date_str.match(BETWEEN_Yn_AND_Yn_BC_REGEX)
+      return ParseDate.send(:year_int_for_bc, date_str) if date_str.match(YEAR_BC_REGEX)
+
+      result ||= ParseDate.send(:between_earliest_year, date_str)
+      result ||= ParseDate.send(:first_four_digits, date_str)
+      result ||= ParseDate.send(:year_from_mm_dd_yy, date_str)
+      result ||= ParseDate.send(:first_year_for_decade, date_str) # 198x or 201x
+      result ||= ParseDate.send(:first_year_for_century, date_str) # includes BC
+      result ||= ParseDate.send(:year_for_early_numeric, date_str)
       unless result
         # try removing brackets between digits in case we have 169[5] or [18]91
-        no_brackets = ParseDate.send(:remove_brackets, orig_date_str)
+        no_brackets = ParseDate.send(:remove_brackets, date_str)
         return earliest_year(no_brackets) if no_brackets
       end
       result.to_i if result && year_int_valid?(result.to_i)
     end
 
-    # latest year as Integer if we can parse one from orig_date_str
+    # latest year as Integer if we can parse one from date_str
     #  e.g. if 17uu, result is 1799
     # NOTE:  if we have a x/x/yy or x-x-yy pattern (the only 2 digit year patterns
     #   found in our actual date strings in stanford-mods records), then
@@ -41,29 +46,36 @@ class ParseDate
     #   1/1/17  ->  2017
     #   1/1/27  ->  1927
     # @return [Integer, nil] Integer year if we could parse one, nil otherwise
-    def self.latest_year(orig_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.
-      # NOTE:  may want to parse for last occurence of 4 consecutive digits
-      return ParseDate.send(:year_int_for_bc, orig_date_str) if orig_date_str.match(BC_REGEX)
-
-      # NOTE:  may want to parse for last occurence of 4 consecutive digits
-      result = ParseDate.send(:first_four_digits, orig_date_str)
-      result ||= ParseDate.send(:year_from_mm_dd_yy, orig_date_str)
-      result ||= ParseDate.send(:last_year_for_decade, orig_date_str) # 19xx or 20xx
-      # NOTE:  may want to parse for last occurence of consecutive digits
-      result ||= ParseDate.send(:last_year_for_century, orig_date_str)
-      result ||= ParseDate.send(:year_for_early_numeric, orig_date_str)
+    def self.latest_year(date_str)
+      return unless date_str && !date_str.empty?
+      return if date_str == '0000-00-00' # shpc collection has these useless dates
+
+      # B.C. first (match longest string first)
+      return ParseDate.send(:last_year_mult_centuries_bc, date_str) if date_str.match(YY_YY_CENTURY_BC_REGEX)
+      return ParseDate.send(:between_bc_latest_year, date_str) if date_str.match(BETWEEN_Yn_AND_Yn_BC_REGEX)
+      return ParseDate.send(:last_year_for_bc_century, date_str) if date_str.match(BC_CENTURY_REGEX)
+      return ParseDate.send(:year_int_for_bc, date_str) if date_str.match(BC_REGEX)
+
+      result ||= ParseDate.send(:between_latest_year, date_str)
+      result ||= ParseDate.send(:hyphen_4digit_latest_year, date_str)
+      result ||= ParseDate.send(:hyphen_2digit_latest_year, date_str)
+      result ||= ParseDate.send(:yyuu_after_hyphen, date_str)
+      result ||= ParseDate.send(:year_after_or, date_str)
+      result ||= ParseDate.send(:first_four_digits, date_str)
+      result ||= ParseDate.send(:year_from_mm_dd_yy, date_str)
+      result ||= ParseDate.send(:last_year_for_decade, date_str) # 198x or 201x
+      result ||= ParseDate.send(:last_year_mult_centuries, date_str) # nth-nth century
+      result ||= ParseDate.send(:last_year_for_century, date_str)
+      result ||= ParseDate.send(:last_year_for_early_numeric, date_str)
       unless result
         # try removing brackets between digits in case we have 169[5] or [18]91
-        no_brackets = ParseDate.send(:remove_brackets, orig_date_str)
+        no_brackets = ParseDate.send(:remove_brackets, date_str)
         return earliest_year(no_brackets) if no_brackets
       end
       result.to_i if result && year_int_valid?(result.to_i)
     end
 
-    # true if the year is between -999 and (current year + 2)
+    # true if the year is between -999 and (current year + 1), inclusive
     # @return [Boolean] true if the year is between -999 and (current year + 1); false otherwise
     def self.year_int_valid?(year)
       return false unless year.is_a? Integer
@@ -73,18 +85,94 @@ class ParseDate
 
     protected
 
-    BRACKETS_BETWEEN_DIGITS_REXEXP = Regexp.new('\d[' + Regexp.escape('[]') + ']\d')
+    REGEX_OPTS = Regexp::IGNORECASE | Regexp::MULTILINE
+    BC_REGEX = Regexp.new(/\s*B\.?\s*C\.?/im)
+    BRACKETS_BETWEEN_DIGITS_REGEX = Regexp.new('\d[' + Regexp.escape('[]') + ']\d')
 
     # removes brackets between digits such as 169[5] or [18]91
-    def remove_brackets(orig_date_str)
-      orig_date_str.delete('[]') if orig_date_str.match(BRACKETS_BETWEEN_DIGITS_REXEXP)
+    def remove_brackets(date_str)
+      date_str.delete('[]') if date_str.match(BRACKETS_BETWEEN_DIGITS_REGEX)
+    end
+
+    YYYY_HYPHEN_YYYY_REGEX = Regexp.new(/(?<first>\d{4})\??\s*-\s*(?<last>\d{4})\??/m)
+
+    # Integer value for latest year if we have "yyyy-yyyy" pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def hyphen_4digit_latest_year(date_str)
+      Regexp.last_match(:last).to_i if date_str.match(YYYY_HYPHEN_YYYY_REGEX)
+    end
+
+    YYYY_HYPHEN_YY_REGEX = Regexp.new(/(?<first>\d{4})\??\s*-\s*(?<last>\d{2})\??([^-0-9].*)?$/)
+
+    # Integer value for latest year if we have "yyyy-yy" pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def hyphen_2digit_latest_year(date_str)
+      matches = date_str.match(YYYY_HYPHEN_YY_REGEX)
+      return unless matches
+
+      first = Regexp.last_match(:first)
+      century = first[0, 2]
+      last = "#{century}#{Regexp.last_match(:last)}"
+      last.to_i if ParseDate.year_range_valid?(first.to_i, last.to_i)
+    end
+
+    YYUU = '\\d{1,2}[u\\-]{2}'
+    YYuu_HYPHEN_YYuu_REGEX = Regexp.new("(?<first>#{YYUU})\\??\\s*-\\s*(?<last>#{YYUU})\\??([^u\\-]|$)??", REGEX_OPTS)
+
+    # Integer value for latest year if we have "yyuu-yyuu" pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def yyuu_after_hyphen(date_str)
+      last_year_for_century(Regexp.last_match(:last)).to_i if date_str.match(YYuu_HYPHEN_YYuu_REGEX)
+    end
+
+    YYXX = '\\d{1,2}[u\\-\\d]{2}'
+    YExx_OR_YExx_REGEX = Regexp.new("(?<first>#{YYXX})\\??\\s*or\\s*(?<last>#{YYXX})\\??([^u\\-]|$)??", REGEX_OPTS)
+
+    # Integer value for latest year if we have "yyyy or yyyy" pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def year_after_or(date_str)
+      latest_year(Regexp.last_match(:last)).to_i if date_str.match(YExx_OR_YExx_REGEX)
+    end
+
+    # NOTE: some actual data seemed to have a diff hyphen char. (slightly longer)
+    YY_YY_CENTURY_REGEX = Regexp.new(/(?<first>\d{1,2})[a-z]{2}?\s*(-|–|or)\s*(?<last>\d{1,2})[a-z]{2}?\s+centur.*/im)
+
+    # Integer value for latest year if we have nth-nth century pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def last_year_mult_centuries(date_str)
+      matches = date_str.match(YY_YY_CENTURY_REGEX)
+      return unless matches
+
+      nth = Regexp.last_match(:last).to_i
+      (nth - 1) * 100 + 99
+    end
+
+    YY_YY_CENTURY_BC_REGEX = Regexp.new("#{YY_YY_CENTURY_REGEX}#{BC_REGEX}", REGEX_OPTS)
+
+    # Integer value for earliest year if we have nth-nth century BC pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def earliest_century_bc(date_str)
+      matches = date_str.match(YY_YY_CENTURY_BC_REGEX)
+      return unless matches
+
+      nth = Regexp.last_match(:first).to_i
+      nth * -100 - 99
+    end
+
+    # Integer value for latest year if we have nth-nth century BC pattern
+    # @return [Integer, nil] yyyy if date_str matches pattern; nil otherwise
+    def last_year_mult_centuries_bc(date_str)
+      matches = date_str.match(YY_YY_CENTURY_BC_REGEX)
+      return unless matches
+
+      nth = Regexp.last_match(:last).to_i
+      nth * -100
     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 first_four_digits(orig_date_str)
-      matches = orig_date_str.match(/\d{4}/) if orig_date_str
-      matches&.to_s
+    # looks for 4 consecutive digits in date_str and returns first occurrence if found
+    # @return [String, nil] 4 digit year (e.g. 1865, 0950) if date_str has yyyy, nil otherwise
+    def first_four_digits(date_str)
+      Regexp.last_match(1) if date_str.match(/(\d{4})([^\d]|$)/im)
     end
 
     # returns 4 digit year as String if we have a x/x/yy or x-x-yy pattern
@@ -92,16 +180,14 @@ class ParseDate
     #   we use 20 as century digits unless it is greater than current year:
     #   1/1/17  ->  2017
     #   1/1/27  ->  1927
-    # @return [String, nil] 4 digit year (e.g. 1865, 0950) if orig_date_str matches pattern, nil otherwise
-    def year_from_mm_dd_yy(orig_date_str)
-      return unless orig_date_str
-
-      slash_matches = orig_date_str.match(/\d{1,2}\/\d{1,2}\/\d{2}/)
+    # @return [String, nil] 4 digit year (e.g. 1865, 0950) if date_str matches pattern, nil otherwise
+    def year_from_mm_dd_yy(date_str)
+      slash_matches = date_str.match(/\d{1,2}\/\d{1,2}\/\d{2}/)
       if slash_matches
-        date_obj = Date.strptime(orig_date_str, '%m/%d/%y')
+        date_obj = Date.strptime(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
+        hyphen_matches = date_str.match(/\d{1,2}-\d{1,2}-\d{2}/)
+        date_obj = Date.strptime(date_str, '%m-%d-%y') if hyphen_matches
       end
       date_obj = Date.new(date_obj.year - 100, date_obj.month, date_obj.mday) if date_obj && date_obj > Date.today
       date_obj.year.to_s if date_obj
@@ -109,66 +195,107 @@ class ParseDate
       nil # explicitly want nil if date won't parse
     end
 
-    DECADE_4CHAR_REGEXP = Regexp.new('(^|\D)\d{3}[u\-?x]')
+    DECADE_4CHAR_REGEX = Regexp.new('(^|\D)\d{3}[u\-?x]', REGEX_OPTS)
 
     # 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 first_year_for_decade(orig_date_str)
-      decade_matches = orig_date_str.match(DECADE_4CHAR_REGEXP) if orig_date_str
+    # @return [String, nil] 4 digit year (e.g. 1860, 1950) if date_str matches pattern, nil otherwise
+    def first_year_for_decade(date_str)
+      decade_matches = date_str.match(DECADE_4CHAR_REGEX)
       changed_to_zero = decade_matches.to_s.tr('u\-?x', '0') if decade_matches
       ParseDate.first_four_digits(changed_to_zero) if changed_to_zero
     end
 
     # last 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 last_year_for_decade(orig_date_str)
-      decade_matches = orig_date_str.match(DECADE_4CHAR_REGEXP) if orig_date_str
+    # @return [String, nil] 4 digit year (e.g. 1869, 1959) if date_str matches pattern, nil otherwise
+    def last_year_for_decade(date_str)
+      decade_matches = date_str.match(DECADE_4CHAR_REGEX)
       changed_to_nine = decade_matches.to_s.tr('u\-?x', '9') if decade_matches
       ParseDate.first_four_digits(changed_to_nine) if changed_to_nine
     end
 
-    CENTURY_WORD_REGEXP = Regexp.new('(\d{1,2}).*century')
-    CENTURY_4CHAR_REGEXP = Regexp.new('(\d{1,2})[u\-]{2}([^u\-]|$)')
+    CENTURY_WORD_REGEX = Regexp.new('(\d{1,2})[a-z]{2}?\s*century', REGEX_OPTS)
+    CENTURY_4CHAR_REGEX = Regexp.new('(\d{1,2})[u\-]{2}([^u\-]|$)', REGEX_OPTS)
+    BC_CENTURY_REGEX = Regexp.new("#{CENTURY_WORD_REGEX}\\s+#{BC_REGEX}", REGEX_OPTS)
+
+    # first year of century if we have:  yyuu, yy--, yy--? or xxth century pattern; handles B.C.
+    # @return [Integer, nil] yy00 if date_str matches pattern, nil otherwise
+    def first_year_for_century(date_str)
+      return Regexp.last_match(1).to_i * -100 - 99 if date_str.match(BC_CENTURY_REGEX)
+      return Regexp.last_match(1).to_i * 100 if date_str.match(CENTURY_4CHAR_REGEX)
+      return (Regexp.last_match(:first).to_i - 1) * 100 if date_str.match(YY_YY_CENTURY_REGEX)
+      return (Regexp.last_match(1).to_i - 1) * 100 if date_str.match(CENTURY_WORD_REGEX)
+    end
+
+    # last year of century if we have:  yyuu, yy--, yy--? or xxth century pattern
+    # @return [Integer, nil] yy99 if date_str matches pattern, nil otherwise; also nil if B.C. in pattern
+    def last_year_for_century(date_str)
+      return Regexp.last_match(1).to_i * 100 + 99 if date_str.match(CENTURY_4CHAR_REGEX)
+      return (Regexp.last_match(1).to_i - 1) * 100 + 99 if date_str.match(CENTURY_WORD_REGEX)
+    end
+
+    # last year of century (as String) if we have:  nth century BC
+    # @return [Integer, nil] yy99 if date_str matches pattern, nil otherwise; also nil if B.C. in pattern
+    def last_year_for_bc_century(date_str)
+      Regexp.last_match(1).to_i * -100 if date_str.match(BC_CENTURY_REGEX)
+    end
+
+    BETWEEN_Yn_AND_Yn_REGEX = Regexp.new(/between\s+(?<first>\d{1,4})\??\s+and\s+(?<last>\d{1,4})\??/im)
 
-    # 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 first_year_for_century(orig_date_str)
-      return unless orig_date_str
-      return if orig_date_str =~ /B\.C\./
-      return "#{Regexp.last_match(1)}00" if orig_date_str.match(CENTURY_4CHAR_REGEXP)
-      return "#{(Regexp.last_match(1).to_i - 1).to_s}00" if orig_date_str.match(CENTURY_WORD_REGEXP)
+    # Integer value for earliest if we have "between y and y" pattern
+    # NOTE: must match for BC first with between_bc_earliest_year
+    # @return [Integer, nil] year if date_str matches pattern; nil otherwise
+    def between_earliest_year(date_str)
+      Regexp.last_match(:first).to_i if date_str.match(BETWEEN_Yn_AND_Yn_REGEX)
     end
 
-    # last 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 last_year_for_century(orig_date_str)
-      return unless orig_date_str
-      return if orig_date_str =~ /B\.C\./
-      return "#{Regexp.last_match(1)}99" if orig_date_str.match(CENTURY_4CHAR_REGEXP)
+    # Integer value for latest year if we have "between y and y" pattern
+    # NOTE: must match for BC first with between_bc_latest_year
+    # @return [Integer, nil] year if date_str matches pattern; nil otherwise
+    def between_latest_year(date_str)
+      Regexp.last_match(:last).to_i if date_str.match(BETWEEN_Yn_AND_Yn_REGEX)
+    end
+
+    YEAR_BC_REGEX = Regexp.new("(\\d{1,4})#{BC_REGEX}", REGEX_OPTS)
 
-      # TODO:  do we want to look for the very last match of digits before "century" instead of the first one?
-      return "#{(Regexp.last_match(1).to_i - 1).to_s}99" if orig_date_str.match(CENTURY_WORD_REGEXP)
+    # Integer value for B.C. if we have B.C. pattern
+    # @return [Integer, nil] -ddd if B.C. in pattern; nil otherwise
+    def year_int_for_bc(date_str)
+      "-#{Regexp.last_match(1)}".to_i if date_str.match(YEAR_BC_REGEX)
     end
 
-    BC_REGEX = Regexp.new('(\d{1,4}).*' + Regexp.escape('B.C.'))
+    BETWEEN_Yn_AND_Yn_BC_REGEX = Regexp.new("#{BETWEEN_Yn_AND_Yn_REGEX}#{BC_REGEX}", REGEX_OPTS)
 
-    # 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 year_int_for_bc(orig_date_str)
-      bc_matches = orig_date_str.match(BC_REGEX) if orig_date_str
-      "-#{Regexp.last_match(1)}".to_i if bc_matches
+    # Integer value for earliest year if we have "between y and y B.C." pattern
+    # @return [Integer, nil] -ddd if date_str matches pattern; nil otherwise
+    def between_bc_earliest_year(date_str)
+      "-#{Regexp.last_match(:first)}".to_i if date_str.match(BETWEEN_Yn_AND_Yn_BC_REGEX)
     end
 
-    EARLY_NUMERIC = Regexp.new('^\-?\d{1,3}$')
+    # Integer value for latest year if we have "between y and y B.C." pattern
+    # @return [Integer, nil] -ddd if date_str matches pattern; nil otherwise
+    def between_bc_latest_year(date_str)
+      "-#{Regexp.last_match(:last)}".to_i if date_str.match(BETWEEN_Yn_AND_Yn_BC_REGEX)
+    end
+
+    EARLY_NUMERIC_REGEX = Regexp.new('^\-?\d{1,3}([^\du\-\[]|$)', REGEX_OPTS)
+
+    # year if date_str contains yyy, yy, y, -y, -yy, -yyy, -yyyy
+    # @return [Integer, nil] year if date_str matches pattern; nil otherwise
+    def year_for_early_numeric(date_str)
+      date_str.to_i if date_str.match(EARLY_NUMERIC_REGEX) || date_str =~ /^-\d{4}([^\du\-\[]|$)$/
+    end
+
+    FIRST_LAST_EARLY_NUMERIC_REGEX =
+      Regexp.new(/^(?<first>\-?\d{1,3})\??\s*(-|–|or)\s*(?<last>\-?\d{1,4})\??([^\du\-\[]|$)/im)
+
+    # Integer value for latest year if we have early numeric year range or single early numeric year
+    # @return [Integer, nil] year if date_str matches pattern; nil otherwise
+    def last_year_for_early_numeric(date_str)
+      return Regexp.last_match(:last).to_i if date_str.match(FIRST_LAST_EARLY_NUMERIC_REGEX)
 
-    # year if orig_date_str contains yyy, yy, y, -y, -yy, -yyy, -yyyy
-    # @return [String, nil] -ddd if orig_date_str matches pattern; nil otherwise
-    def year_for_early_numeric(orig_date_str)
-      orig_date_str if orig_date_str.match(EARLY_NUMERIC) || orig_date_str =~ /^-\d{4}$/
+      year_for_early_numeric(date_str) # if single year, not matched above
     end
   end
 end

data/lib/parse_date/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class ParseDate
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parse_date
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Naomi Dushay
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-09 00:00:00.000000000 Z
+date: 2019-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk