mods 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c05154eec0a38fc2a0ad117d1c47fb336c116edf
-  data.tar.gz: 9cbbfe083b89d92d0c18355be44136b82693e523
+  metadata.gz: b02fccf6e03afe427a8c23d821ebb2692b635f6d
+  data.tar.gz: d7f7fd87cd6ba14ab473dea40383f550f4cfa1e2
 SHA512:
-  metadata.gz: 7d2ebefc59ba8cf3f6cdd816d429c45b238181158840aef30b34c806830d3c33de5dab7fcc76be3527a6f40ffe174e2087fc3e43ad17fe236a4d38e06f990c49
-  data.tar.gz: 6ccff614c507ec6f3f541793d0407d90ef90ea8af5d38cb038cfdf560514ec4320e88ee74de60d5647db34f3e5de4b71aec071c9fcd8db7d8610a0ce22543a88
+  metadata.gz: e56288c902a448a532169703b9b8b49f95cc3e75a8b0351e8b893acf184caaf3090127b5f33c3c88ecaa0258afdc1d8b3312f963ea50aaaa7943bd7a97724c0a
+  data.tar.gz: 1aed6aa3932542f098d7a200f7c94f4210b3151f308da23eb668f01ce1f9c3a03028cb8af2206d6cef1b632149370bbdd815dfa37c7a02e8aa42ccc042c996d2

data/lib/mods/date.rb

@@ -23,14 +23,21 @@ module Mods
       # when 'temper'
       #   Mods::Date::TemperFormat.new(xml)
       else
-        date_class = [
+        date_class = Mods::Date if xml.text =~ /\p{Hebrew}/
+        date_class ||= [
           MMDDYYYYFormat,
           MMDDYYFormat,
+          YearRangeFormat,
+          DecadeAsYearDashFormat,
+          EmbeddedBCYearFormat,
           EmbeddedYearFormat,
+          EmbeddedThreeDigitYearFormat,
+          EmbeddedYearWithBracketsFormat,
+          MysteryCenturyFormat,
+          CenturyFormat,
           RomanNumeralCenturyFormat,
           RomanNumeralYearFormat,
-          MysteryCenturyFormat,
-          CenturyFormat
+          OneOrTwoDigitYearFormat
         ].select { |klass| klass.supports? xml.text }.first
 
         (date_class || Mods::Date).new(xml)
@@ -42,7 +49,7 @@ module Mods
     # Strict ISO8601-encoded date parser
     class Iso8601Format < Date
       def self.parse_date(text)
-        @date = ::Date.parse(cleanup(text))
+        @date = ::Date.parse(normalize_to_edtf(text))
       end
     end
 
@@ -54,18 +61,18 @@ module Mods
     class EdtfFormat < Date
       attr_reader :date
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         text
       end
     end
 
     # MARC-formatted date parser, similar to EDTF, but with special support for
     # MARC-specific encodings
-    class MarcFormat < EdtfFormat
-      def self.cleanup(text)
-        return nil if text == "9999" || text == "uuuu"
+    class MarcFormat < Date
+      def self.normalize_to_edtf(text)
+        return nil if text == "9999" || text == "uuuu" || text == '||||'
 
-        text.gsub(/^[\[]+/, '').gsub(/[\.\]]+$/, '')
+        super
       end
 
       private
@@ -93,13 +100,13 @@ module Mods
       end
     end
 
-    # Full text extractor for MM/DD/YYYY-formatted dates
+    # Full text extractor for MM/DD/YYYY and MM/DD/YYY-formatted dates
     class MMDDYYYYFormat < ExtractorDateFormat
-      REGEX = /(?<month>\d{1,2})\/(?<day>\d{1,2})\/(?<year>\d{4})/
+      REGEX = /(?<month>\d{1,2})\/(?<day>\d{1,2})\/(?<year>\d{3,4})/
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(self::REGEX)
-        "#{matches[:year].rjust(2, "0")}-#{matches[:month].rjust(2, "0")}-#{matches[:day].rjust(2, "0")}"
+        "#{matches[:year].rjust(4, "0")}-#{matches[:month].rjust(2, "0")}-#{matches[:day].rjust(2, "0")}"
       end
     end
 
@@ -107,7 +114,7 @@ module Mods
     class MMDDYYFormat < ExtractorDateFormat
       REGEX = /(?<month>\d{1,2})\/(?<day>\d{1,2})\/(?<year>\d{2})/
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(self::REGEX)
         year = munge_to_yyyy(matches[:year])
         "#{year}-#{matches[:month].rjust(2, "0")}-#{matches[:day].rjust(2, "0")}"
@@ -124,15 +131,15 @@ module Mods
 
     # Full-text extractor for dates encoded as Roman numerals
     class RomanNumeralYearFormat < ExtractorDateFormat
-      REGEX = /^(?<year>[MCDLXVI]+)/
+      REGEX = /(?<![A-Za-z\.])(?<year>[MCDLXVI\.]+)(?![A-Za-z])/
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(REGEX)
         roman_to_int(matches[:year].upcase).to_s
       end
 
       def self.roman_to_int(value)
-        value = value.dup
+        value = value.tr('.', '')
         map = { "M"=>1000, "CM"=>900, "D"=>500, "CD"=>400, "C"=>100, "XC"=>90, "L"=>50, "XL"=>40, "X"=>10, "IX"=>9, "V"=>5, "IV"=>4, "I"=>1 }
         result = 0
         map.each do |k,v|
@@ -145,11 +152,12 @@ module Mods
       end
     end
 
-    # Full-text extractor for centuries encoded as Roman numerals
+    # Full-text extractor for centuries encoded as Roman numerals; sometimes centuries
+    # are given as e.g. xvith, hence the funny negative look-ahead assertion
     class RomanNumeralCenturyFormat < RomanNumeralYearFormat
-      REGEX = /(cent. )?(?<century>[xvi]+)/
+      REGEX = /(?<![a-z])(?<century>[xvi]+)(?![a-su-z])/
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(REGEX)
         munge_to_yyyy(matches[:century])
       end
@@ -165,7 +173,7 @@ module Mods
     # of unknown origin.
     class MysteryCenturyFormat < ExtractorDateFormat
       REGEX = /(?<century>\d{2})--/
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(REGEX)
         "#{matches[:century]}XX"
       end
@@ -175,22 +183,83 @@ module Mods
     class CenturyFormat < ExtractorDateFormat
       REGEX = /(?<century>\d{2})th C(entury)?/i
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(REGEX)
         "#{matches[:century].to_i - 1}XX"
       end
     end
 
+    # Full-text extractor for data formatted as YYYY-YYYY or YYY-YYY
+    class YearRangeFormat < ExtractorDateFormat
+      REGEX = /(?<start>\d{3,4})-(?<end>\d{3,4})/
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "#{matches[:start].rjust(4, "0")}/#{matches[:end].rjust(4, "0")}"
+      end
+    end
+
+    # Full-text extractor for data formatted as YYY-
+    class DecadeAsYearDashFormat < ExtractorDateFormat
+      REGEX = /(?<!\d)(?<year>\d{3})[-_x?](?!\d)/
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "#{matches[:year]}X"
+      end
+    end
+
+    # Full-text extractor that tries hard to pick any year present in the data
+    class EmbeddedBCYearFormat < ExtractorDateFormat
+      REGEX = /(?<year>\d{3,4})\s?B\.?C\.?/i
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "-#{(matches[:year].to_i - 1).to_s.rjust(4, "0")}"
+      end
+    end
+
     # Full-text extractor that tries hard to pick any year present in the data
     class EmbeddedYearFormat < ExtractorDateFormat
-      REGEX = /(?<prefix>-)?(?<year>\d{3,4})/
+      REGEX = /(?<prefix>-)?(?<!\d)(?<year>\d{4})(?!\d)/
 
-      def self.cleanup(text)
+      def self.normalize_to_edtf(text)
         matches = text.match(REGEX)
         "#{matches[:prefix]}#{matches[:year].rjust(4, "0")}"
       end
     end
 
+    # Full-text extractor that tries hard to pick any year present in the data
+    class EmbeddedThreeDigitYearFormat < ExtractorDateFormat
+      REGEX = /(?<prefix>-)?(?<!\d)(?<year>\d{3})(?!\d)(?!\d)/
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "#{matches[:prefix]}#{matches[:year].rjust(4, "0")}"
+      end
+    end
+
+    # Full-text extractor that tries hard to pick any year present in the data
+    class OneOrTwoDigitYearFormat < ExtractorDateFormat
+      REGEX = /^(?<prefix>-)?(?<year>\d{1,2})$/
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "#{matches[:prefix]}#{matches[:year].rjust(4, "0")}"
+      end
+    end
+
+    # Full-text extractor that tries hard to pick any year present in the data
+    class EmbeddedYearWithBracketsFormat < ExtractorDateFormat
+      # [YYY]Y Y[YYY] [YY]YY Y[YY]Y YY[YY] YYY[Y] YY[Y]Y Y[Y]YY [Y]YYY
+      REGEX = /(?<prefix>-)?(?<year>[\d\[\]]{6})(?!\d)/
+
+      def self.normalize_to_edtf(text)
+        matches = text.match(REGEX)
+        "#{matches[:prefix]}#{matches[:year].gsub('[', '').gsub(']', '')}"
+      end
+    end
+
     attr_reader :date
 
     ##
@@ -199,20 +268,24 @@ module Mods
     # @param [String] text
     # @return [Date]
     def self.parse_date(text)
-      ::Date.edtf(cleanup(text))
+      return nil if text == '0000-00-00'
+      ::Date.edtf(normalize_to_edtf(text))
     end
 
     ##
     # Apply any encoding-specific munging or text extraction logic
     # @param [String] text
     # @return [String]
-    def self.cleanup(text)
-      text.gsub(/^[\[]+/, '').gsub(/[\.\]]+$/, '')
+    def self.normalize_to_edtf(text)
+      sanitized = text.gsub(/^[\[]+/, '').gsub(/[\.\]]+$/, '')
+      sanitized = text.rjust(4, "0") if text =~ /^\d{3}$/
+
+      sanitized
     end
 
     def initialize(xml)
       @xml = xml
-      @date = self.class.parse_date(xml.text)
+      @date = self.class.parse_date(xml.text.strip)
     end
 
     ##
@@ -265,6 +338,14 @@ module Mods
       xml.attr(:encoding)
     end
 
+    ##
+    # Is the date marked as a keyDate?
+    #
+    # @return [Boolean]
+    def key?
+      xml.attr(:keyDate) == 'yes'
+    end
+
     ##
     # Was an encoding provided?
     #
@@ -337,6 +418,25 @@ module Mods
       qualifier == 'questionable'
     end
 
+    def precision
+      if date_range.is_a? EDTF::Century
+        :century
+      elsif date_range.is_a? EDTF::Decade
+        :decade
+      else
+        case date.precision
+        when :month
+          date.unspecified.unspecified?(:month) ? :year : :month
+        when :day
+          d = date.unspecified.unspecified?(:day) ? :month : :day
+          d = date.unspecified.unspecified?(:month) ? :year : d
+          d
+        else
+          date.precision
+        end
+      end
+    end
+
     private
 
     def days_in_month(month, year)
@@ -356,15 +456,18 @@ module Mods
       return nil if date.nil?
 
       case date_range
+      when EDTF::Unknown
+        nil
       when EDTF::Epoch, EDTF::Interval
         date_range.min
       when EDTF::Set
         date_range.to_a.first
       else
         d = date.dup
-        d = d.change(month: 1, day: 1) if date.unspecified.unspecified?(:year) || date.precision == :year
-        d = d.change(month: 1) if date.unspecified.unspecified?(:month) || date.precision == :year
-        d = d.change(day: 1) if date.unspecified.unspecified?(:day) || date.precision == :month
+        d = d.change(month: 1, day: 1) if date.precision == :year
+        d = d.change(day: 1) if date.precision == :month
+        d = d.change(month: 1) if date.unspecified.unspecified? :month
+        d = d.change(day: 1) if date.unspecified.unspecified? :day
         d
       end
     end
@@ -376,16 +479,20 @@ module Mods
     # @return [::Date]
     def latest_date
       return nil if date.nil?
+
       case date_range
+      when EDTF::Unknown
+        nil
       when EDTF::Epoch, EDTF::Interval
         date_range.max
       when EDTF::Set
         date_range.to_a.last.change(month: 12, day: 31)
       else
         d = date.dup
-        d = d.change(month: 12, day: 31) if date.unspecified.unspecified?(:year) || date.precision == :year
-        d = d.change(month: 12) if date.unspecified.unspecified?(:month) || date.precision == :year
-        d = d.change(day: days_in_month(date.month, date.year)) if date.unspecified.unspecified?(:day) || date.precision == :month
+        d = d.change(month: 12, day: 31) if date.precision == :year
+        d = d.change(day: days_in_month(date.month, date.year)) if date.precision == :month
+        d = d.change(month: 12) if date.unspecified.unspecified? :month
+        d = d.change(day: days_in_month(date.month, date.year)) if date.unspecified.unspecified? :day
         d
       end
     end

data/lib/mods/version.rb

@@ -1,4 +1,4 @@
 module Mods
   # this is the Ruby Gem version
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end

data/spec/date_spec.rb

@@ -72,6 +72,46 @@ RSpec.describe Mods::Date do
     end
   end
 
+  describe '#key?' do
+    context 'with keyDate=yes' do
+      let(:date_element) { "<dateCreated keyDate='yes'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.key?).to eq true
+      end
+    end
+
+    context 'with a keyDate set to anything else' do
+      let(:date_element) { "<dateCreated keyDate='fictional'>1856</dateCreated>" }
+
+      it 'returns false' do
+        expect(date.key?).to eq false
+      end
+    end
+  end
+
+  describe '#precision' do
+    {
+      '1905' => :year,
+      '190u' => :decade,
+      '19uu' => :century,
+      '1900-uu' => :year,
+      '1900-uu-uu' => :year,
+      '1900-uu-15' => :year,
+      '1900-06' => :month,
+      '1900-06-uu' => :month,
+      '1900-06-15' => :day,
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated encoding=\"edtf\">#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date.precision).to eq expected
+        end
+      end
+    end
+  end
+
   describe '#point' do
     let(:date_element) { "<dateCreated point='fictional'>1856</dateCreated>" }
 
@@ -188,7 +228,8 @@ RSpec.describe Mods::Date do
       '-1753' => Date.parse('-1753-01-01')..Date.parse('-1753-12-31'),
       '1992-05-06' => Date.parse('1992-05-06')..Date.parse('1992-05-06'),
       '1992-04' => Date.parse('1992-04-01')..Date.parse('1992-04-30'),
-      '2004-02' => Date.parse('2004-02-01')..Date.parse('2004-02-29')
+      '2004-02' => Date.parse('2004-02-01')..Date.parse('2004-02-29'),
+      '123' => Date.parse('123-01-01')..Date.parse('123-12-31') # not technically valid, but we have lots of these
     }.each do |data, expected|
       describe "with #{data}" do
         let(:date_element) { "<dateCreated encoding=\"w3cdtf\">#{data}</dateCreated>" }
@@ -206,7 +247,8 @@ RSpec.describe Mods::Date do
     {
       '1234' => Date.parse('1234-01-01')..Date.parse('1234-12-31'),
       '9999' => nil,
-      '1uuu' => Date.parse('1000-01-01')..Date.parse('1999-12-31')
+      '1uuu' => Date.parse('1000-01-01')..Date.parse('1999-12-31'),
+      '||||' => nil
     }.each do |data, expected|
       describe "with #{data}" do
         let(:date_element) { "<dateCreated encoding=\"marc\">#{data}</dateCreated>" }
@@ -243,7 +285,8 @@ RSpec.describe Mods::Date do
       '5/2/2017' => Date.parse('2017-05-02')..Date.parse('2017-05-02'),
       '12/1/2017' => Date.parse('2017-12-01')..Date.parse('2017-12-01'),
       '12/1/17' => Date.parse('2017-12-01')..Date.parse('2017-12-01'),
-      '12/1/25' => Date.parse('1925-12-01')..Date.parse('1925-12-01')
+      '12/1/25' => Date.parse('1925-12-01')..Date.parse('1925-12-01'),
+      '6/18/938' => Date.parse('0938-06-18')..Date.parse('0938-06-18')
     }.each do |data, expected|
       describe "with #{data}" do
         let(:date_element) { "<dateCreated>#{data}</dateCreated>" }
@@ -269,7 +312,22 @@ RSpec.describe Mods::Date do
       'MDLXXVIII' => Date.parse('1578-01-01')..Date.parse('1578-12-31'),
       '[19--?]-' => Date.parse('1900-01-01')..Date.parse('1999-12-31'),
       '19th Century' => Date.parse('1800-01-01')..Date.parse('1899-12-31'),
-      '19th c.' => Date.parse('1800-01-01')..Date.parse('1899-12-31')
+      '19th c.' => Date.parse('1800-01-01')..Date.parse('1899-12-31'),
+      'mid to 2nd half of 13th century' => Date.parse('1200-01-01')..Date.parse('1299-12-31'),
+      '167-?]' => Date.parse('1670-01-01')..Date.parse('1679-12-31'),
+      '189-?' => Date.parse('1890-01-01')..Date.parse('1899-12-31'),
+      '193-' => Date.parse('1930-01-01')..Date.parse('1939-12-31'),
+      '196_' => Date.parse('1960-01-01')..Date.parse('1969-12-31'),
+      '196x' => Date.parse('1960-01-01')..Date.parse('1969-12-31'),
+      '186?' => Date.parse('1860-01-01')..Date.parse('1869-12-31'),
+      '1700?' => Date.parse('1700-01-01')..Date.parse('1700-12-31'),
+      '[1670-1684]' => Date.parse('1670-01-01')..Date.parse('1684-12-31'),
+      '[18]74' => Date.parse('1874-01-01')..Date.parse('1874-12-31'),
+      '250 B.C.' => Date.parse('-0249-01-01')..Date.parse('-249-12-31'),
+      'Anno M.DC.LXXXI.' => Date.parse('1681-01-01')..Date.parse('1681-12-31'),
+      '624[1863 or 1864]' => Date.parse('1863-01-01')..Date.parse('1863-12-31'),
+      'chez Villeneuve' => nil,
+      '‏4264681 או 368' => nil
     }.each do |data, expected|
       describe "with #{data}" do
         let(:date_element) { "<dateCreated>#{data}</dateCreated>" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mods
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Naomi Dushay
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-01 00:00:00.000000000 Z
+date: 2017-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri