parse_date 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67507d7ddc6be0cff379b210ca3985316153e96823ee573f6292298746fd25f7
-  data.tar.gz: 87ffbb778c68a34a472f99429252172bb676738d48a6776e3a5195b871397afd
+  metadata.gz: 446afc4299ca93634d6689b20d3a32bdb28460da5627701682733e18bb1f0a16
+  data.tar.gz: b5f6bbceab8542cc3c977c1c1ea8a4e250f82a9ae3a1eed2b335050067145703
 SHA512:
-  metadata.gz: a89b5cd3b4712bae4a0d82e5624b2463a10719243b19cc5d4b28d6d95db2ed097691fcc4c0a39a6e319db46cb0d6a6972b2bdda9530b6fc3d75d5e52e7ba6fcf
-  data.tar.gz: 634e22955684ec3176217d4ebfe16434bcffca287b8d64f30a53332c93e2b992cd995997956799aec53e0b7a68560de49ba23cdf6efdaf332dd4bad6ef91e18e
+  metadata.gz: 052f5d35a64c52f5bd74af2e487b70c8b03c37252cce33554aa3e7d6ba8141d9f0edd7c719aa487dbddb2e465b76d2d1ab222f057e68c7e6fa322eef313a35e6
+  data.tar.gz: 880e66962d42d0c3f2824510a94edcf9256cc6ba8298815721a2a720e8f9ef2158793820ff71fc3a22a0ad0f3397db3f8e2361753ee661494ed1371117562eb7

data/.rubocop_todo.yml

@@ -1,26 +1,32 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2019-10-01 18:08:41 -0700 using RuboCop version 0.74.0.
+# on 2019-10-09 15:35:45 -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
 Metrics/AbcSize:
-  Max: 22
+  Max: 18
 
-# Offense count: 2
+# Offense count: 4
 # Configuration parameters: CountComments, ExcludedMethods.
 # ExcludedMethods: refine
 Metrics/BlockLength:
-  Max: 512
+  Max: 561
 
 # Offense count: 3
 Metrics/CyclomaticComplexity:
-  Max: 9
+  Max: 8
 
-# Offense count: 2
+# Offense count: 1
 Metrics/PerceivedComplexity:
   Max: 9
 
@@ -54,3 +60,11 @@ Style/RegexpLiteral:
 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'

data/README.md

@@ -1,4 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/parse_date.svg)](https://badge.fury.io/rb/preservation-client)
+[![Gem Version](https://badge.fury.io/rb/parse_date.svg)](https://badge.fury.io/rb/parse_date)
 [![Build Status](https://travis-ci.org/sul-dlss/parse_date.svg?branch=master)](https://travis-ci.org/sul-dlss/parse_date)
 [![Maintainability](https://api.codeclimate.com/v1/badges/2d006b4ccb3100434f4a/maintainability)](https://codeclimate.com/github/sul-dlss/parse_date/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/2d006b4ccb3100434f4a/test_coverage)](https://codeclimate.com/github/sul-dlss/parse_date/test_coverage)
@@ -30,14 +30,25 @@ ParseDate has class methods for date string parsing.
 ```
 require 'parse_date'
 
-ParseDate.year_int_from_date_str('12/25/00') # 2000
-ParseDate.year_int_from_date_str('5-1-21') # 1921
-ParseDate.year_int_from_date_str('18th century CE') # 1700
-ParseDate.year_int_from_date_str('1666 B.C.') # -1666
-ParseDate.year_int_from_date_str('17uu') # 1700
-ParseDate.year_int_from_date_str('-914') # -914
-ParseDate.year_int_from_date_str('[c1926]') # 1926
-ParseDate.year_int_from_date_str('ca. 1558') # 1558
+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

data/lib/parse_date.rb

@@ -25,12 +25,15 @@ class ParseDate
   include Singleton
   extend ParseDate::IntFromString
 
-  # class method delegation for ParseDate.year_int_from_date_str
-  def self.year_int_from_date_str(orig_date_str)
-    ParseDate::IntFromString.year_int_from_date_str(orig_date_str)
+  # class method delegation
+  def self.earliest_year(orig_date_str)
+    ParseDate::IntFromString.earliest_year(orig_date_str)
+  end
+
+  def self.latest_year(orig_date_str)
+    ParseDate::IntFromString.latest_year(orig_date_str)
   end
 
-  # class method delegation for ParseDate.year_int_valid?
   def self.year_int_valid?(orig_date_str)
     ParseDate::IntFromString.year_int_valid?(orig_date_str)
   end

data/lib/parse_date/int_from_string.rb

@@ -7,31 +7,63 @@ class ParseDate
   # Parse (Year) Integers from Date Strings
   module IntFromString
 
-    # get Integer year if we can parse date_str to get a year.
+    # earliest year as Integer if we can parse one from orig_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
     #   we use 20 as century digits unless it is greater than current year:
     #   1/1/17  ->  2017
     #   1/1/27  ->  1927
     # @return [Integer, nil] Integer year if we could parse one, nil otherwise
-    def self.year_int_from_date_str(orig_date_str)
+    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(:sortable_year_int_for_bc, orig_date_str) if orig_date_str.match(BC_REGEX)
+      return ParseDate.send(:year_int_for_bc, orig_date_str) if orig_date_str.match(BC_REGEX)
 
-      result = ParseDate.send(:sortable_year_for_yyyy_or_yy, orig_date_str)
-      result ||= ParseDate.send(:sortable_year_for_decade, orig_date_str) # 19xx or 20xx
-      result ||= ParseDate.send(:sortable_year_for_century, orig_date_str)
-      result ||= ParseDate.send(:sortable_year_int_for_early_numeric, orig_date_str)
+      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)
       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)
-        return year_int_from_date_str(no_brackets) if no_brackets
+        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 + 1)
+    # latest year as Integer if we can parse one from orig_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
+    #   we use 20 as century digits unless it is greater than current year:
+    #   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)
+      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)
+        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)
     # @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
@@ -41,16 +73,6 @@ class ParseDate
 
     protected
 
-    # 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_or_yy(orig_date_str)
-      # most date strings have a four digit year
-      result = ParseDate.sortable_year_for_yyyy(orig_date_str)
-      result ||= ParseDate.sortable_year_for_yy(orig_date_str) # 19xx or 20xx
-      result
-    end
-
     BRACKETS_BETWEEN_DIGITS_REXEXP = Regexp.new('\d[' + Regexp.escape('[]') + ']\d')
 
     # removes brackets between digits such as 169[5] or [18]91
@@ -60,18 +82,18 @@ class ParseDate
 
     # 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(orig_date_str)
+    def first_four_digits(orig_date_str)
       matches = orig_date_str.match(/\d{4}/) if orig_date_str
       matches&.to_s
     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 stanford-mods records
+    #   note that these are the only 2 digit year patterns found in stanford-mods date fields
     #   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 sortable_year_for_yy(orig_date_str)
+    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}/)
@@ -89,57 +111,64 @@ class ParseDate
 
     DECADE_4CHAR_REGEXP = Regexp.new('(^|\D)\d{3}[u\-?x]')
 
-    # get first year of decade (as String) if we have:  yyyu, yyy-, yyy? or yyyx pattern
+    # 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(orig_date_str)
+    def first_year_for_decade(orig_date_str)
       decade_matches = orig_date_str.match(DECADE_4CHAR_REGEXP) if orig_date_str
       changed_to_zero = decade_matches.to_s.tr('u\-?x', '0') if decade_matches
-      ParseDate.sortable_year_for_yyyy(changed_to_zero) if changed_to_zero
+      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
+      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\-]|$)')
 
-    # get first year of century (as String) if we have:  yyuu, yy--, yy--? or xxth century pattern
+    # 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(orig_date_str)
+    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)
+    end
 
-      century_matches = orig_date_str.match(CENTURY_4CHAR_REGEXP)
-      if century_matches
-        m = Regexp.last_match(1)
-        return m + '00' if m.length == 2
-        return '0' + m + '00' if m.length == 1
-      end
-
-      century_str_matches = orig_date_str.match(CENTURY_WORD_REGEXP)
-      return unless century_str_matches
+    # 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)
 
-      yy = (Regexp.last_match(1).to_i - 1).to_s
-      return yy + '00' if yy.length == 2
-      return '0' + yy + '00' if yy.length == 1
+      # 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)
     end
 
     BC_REGEX = Regexp.new('(\d{1,4}).*' + Regexp.escape('B.C.'))
 
-    # get Integer sortable value for B.C. if we have B.C. pattern
+    # 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(orig_date_str)
+    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
     end
 
     EARLY_NUMERIC = Regexp.new('^\-?\d{1,3}$')
 
-    # 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(orig_date_str)
-      return orig_date_str.to_i if orig_date_str.match(EARLY_NUMERIC)
-
-      orig_date_str.to_i if orig_date_str =~ /^-\d{4}$/
+    # 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}$/
     end
   end
 end

data/lib/parse_date/version.rb

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

metadata

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