mods 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 647ec59551ee3659ad2773521607be33a427e17d
-  data.tar.gz: 8db65d1df9ce8ed378a65fbceff90cb3b9fa8b7a
+  metadata.gz: c05154eec0a38fc2a0ad117d1c47fb336c116edf
+  data.tar.gz: 9cbbfe083b89d92d0c18355be44136b82693e523
 SHA512:
-  metadata.gz: c403fba107f834d3e57a173aaf28762a82cc815b66ba08df1c63610e4ce20197d545d88f06f67f50ae80039da1aff7d5b18912564c5f5a8ff270dd435e82d3ad
-  data.tar.gz: e063dc8a2fdc7a039c8eac7723409369d2473938b972653ac53ef27839d7cc2a5bee82912068effc340a3588811169b51e61ac518748065f7afd43f27755bea4
+  metadata.gz: 7d2ebefc59ba8cf3f6cdd816d429c45b238181158840aef30b34c806830d3c33de5dab7fcc76be3527a6f40ffe174e2087fc3e43ad17fe236a4d38e06f990c49
+  data.tar.gz: 6ccff614c507ec6f3f541793d0407d90ef90ea8af5d38cb038cfdf560514ec4320e88ee74de60d5647db34f3e5de4b71aec071c9fcd8db7d8610a0ce22543a88

data/.gitignore

@@ -21,3 +21,4 @@ tmp
 tmtags
 .idea/*
 to_delete
+.byebug_history

data/Gemfile

@@ -9,3 +9,4 @@ end
 
 # Pin to activesupport 4.x for older versions of ruby
 gem 'activesupport', '~> 4.2' if RUBY_VERSION < '2.2.2'
+gem 'byebug'

data/lib/mods.rb

@@ -4,13 +4,17 @@ require 'nom/xml'
 module Mods
   require 'mods/constants'
   require 'mods/nom_terminology'
+  require 'mods/date'
   require 'mods/marc_country_codes'
   require 'mods/marc_geo_area_codes'
   require 'mods/marc_relator_codes'
   require 'mods/name'
+  require 'mods/origin_info'
   require 'mods/reader'
   require 'mods/record'
   require 'mods/subject'
   require 'mods/title_info'
   require 'mods/version'
+
+  ORIGIN_INFO_DATE_ELEMENTS = Mods::OriginInfo::DATE_ELEMENTS
 end

data/lib/mods/constants.rb

@@ -1,11 +1,11 @@
 module Mods
   # the version of MODS supported by this gem
   MODS_VERSION = '3.4'
-  
+
   MODS_NS_V3 = "http://www.loc.gov/mods/v3"
   MODS_NS = MODS_NS_V3
   MODS_XSD = "http://www.loc.gov/standards/mods/mods.xsd"
-  
+
   DOC_URL = "http://www.loc.gov/standards/mods/"
 
   # top level elements that cannot have subelement children
@@ -40,7 +40,7 @@ module Mods
   # enumerated attribute values
   TITLE_INFO_TYPES = ['abbreviated', 'translated', 'alternative', 'uniform']
   RELATED_ITEM_TYPES = [
-    'preceding', 'succeeding', 'original', 'host', 'constituent', 'series', 
+    'preceding', 'succeeding', 'original', 'host', 'constituent', 'series',
     'otherVersion', 'otherFormat', 'isReferencedBy', 'references', 'reviewOf'
     ]
 
@@ -51,10 +51,7 @@ module Mods
   'still image',
   'moving image',
   'three dimensional object',
-  'software', 
+  'software',
   'multimedia',
   'mixed material']
-  
-  ORIGIN_INFO_DATE_ELEMENTS = ['dateIssued', 'dateCreated', 'dateCaptured', 'dateValid', 'dateModified', 'copyrightDate', 'dateOther']
-
-end
+end

data/lib/mods/date.rb

@@ -0,0 +1,401 @@
+require 'edtf'
+
+module Mods
+  class Date
+    attr_reader :xml
+
+    ##
+    # Ugly date factory that tries to pick an appropriate parser for the
+    # type of data.
+    #
+    # @param [Nokogiri::XML::Element] xml A date-flavored MODS field from the XML
+    # @return [Mods::Date]
+    def self.from_element(xml)
+      case xml.attr(:encoding)
+      when 'w3cdtf'
+        Mods::Date::W3cdtfFormat.new(xml)
+      when 'iso8601'
+        Mods::Date::Iso8601Format.new(xml)
+      when 'marc'
+        Mods::Date::MarcFormat.new(xml)
+      when 'edtf'
+        Mods::Date::EdtfFormat.new(xml)
+      # when 'temper'
+      #   Mods::Date::TemperFormat.new(xml)
+      else
+        date_class = [
+          MMDDYYYYFormat,
+          MMDDYYFormat,
+          EmbeddedYearFormat,
+          RomanNumeralCenturyFormat,
+          RomanNumeralYearFormat,
+          MysteryCenturyFormat,
+          CenturyFormat
+        ].select { |klass| klass.supports? xml.text }.first
+
+        (date_class || Mods::Date).new(xml)
+      end
+    rescue
+      Mods::Date.new(xml)
+    end
+
+    # Strict ISO8601-encoded date parser
+    class Iso8601Format < Date
+      def self.parse_date(text)
+        @date = ::Date.parse(cleanup(text))
+      end
+    end
+
+    # Less strict W3CDTF-encoded date parser
+    class W3cdtfFormat < Date
+    end
+
+    # Strict EDTF parser
+    class EdtfFormat < Date
+      attr_reader :date
+
+      def self.cleanup(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"
+
+        text.gsub(/^[\[]+/, '').gsub(/[\.\]]+$/, '')
+      end
+
+      private
+
+      def earliest_date
+        if xml.text == '1uuu'
+          ::Date.parse('1000-01-01')
+        else
+          super
+        end
+      end
+
+      def latest_date
+        if xml.text == '1uuu'
+          ::Date.parse('1999-12-31')
+        else
+          super
+        end
+      end
+    end
+
+    class ExtractorDateFormat < Date
+      def self.supports?(text)
+        text.match self::REGEX
+      end
+    end
+
+    # Full text extractor for MM/DD/YYYY-formatted dates
+    class MMDDYYYYFormat < ExtractorDateFormat
+      REGEX = /(?<month>\d{1,2})\/(?<day>\d{1,2})\/(?<year>\d{4})/
+
+      def self.cleanup(text)
+        matches = text.match(self::REGEX)
+        "#{matches[:year].rjust(2, "0")}-#{matches[:month].rjust(2, "0")}-#{matches[:day].rjust(2, "0")}"
+      end
+    end
+
+    # Full text extractor for MM/DD/YY-formatted dates
+    class MMDDYYFormat < ExtractorDateFormat
+      REGEX = /(?<month>\d{1,2})\/(?<day>\d{1,2})\/(?<year>\d{2})/
+
+      def self.cleanup(text)
+        matches = text.match(self::REGEX)
+        year = munge_to_yyyy(matches[:year])
+        "#{year}-#{matches[:month].rjust(2, "0")}-#{matches[:day].rjust(2, "0")}"
+      end
+
+      def self.munge_to_yyyy(text)
+        if text.to_i > (::Date.current.year - 2000)
+          "19#{text}"
+        else
+          "20#{text}"
+        end
+      end
+    end
+
+    # Full-text extractor for dates encoded as Roman numerals
+    class RomanNumeralYearFormat < ExtractorDateFormat
+      REGEX = /^(?<year>[MCDLXVI]+)/
+
+      def self.cleanup(text)
+        matches = text.match(REGEX)
+        roman_to_int(matches[:year].upcase).to_s
+      end
+
+      def self.roman_to_int(value)
+        value = value.dup
+        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|
+          while value.index(k) == 0
+            result += v
+            value.slice! k
+          end
+        end
+        result
+      end
+    end
+
+    # Full-text extractor for centuries encoded as Roman numerals
+    class RomanNumeralCenturyFormat < RomanNumeralYearFormat
+      REGEX = /(cent. )?(?<century>[xvi]+)/
+
+      def self.cleanup(text)
+        matches = text.match(REGEX)
+        munge_to_yyyy(matches[:century])
+      end
+
+      def self.munge_to_yyyy(text)
+        value = roman_to_int(text.upcase)
+        (value - 1).to_s.rjust(2, "0") + 'XX'
+      end
+    end
+
+
+    # Full-text extractor for a flavor of century encoding present in Stanford data
+    # of unknown origin.
+    class MysteryCenturyFormat < ExtractorDateFormat
+      REGEX = /(?<century>\d{2})--/
+      def self.cleanup(text)
+        matches = text.match(REGEX)
+        "#{matches[:century]}XX"
+      end
+    end
+
+    # Full-text extractor for dates given as centuries
+    class CenturyFormat < ExtractorDateFormat
+      REGEX = /(?<century>\d{2})th C(entury)?/i
+
+      def self.cleanup(text)
+        matches = text.match(REGEX)
+        "#{matches[:century].to_i - 1}XX"
+      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})/
+
+      def self.cleanup(text)
+        matches = text.match(REGEX)
+        "#{matches[:prefix]}#{matches[:year].rjust(4, "0")}"
+      end
+    end
+
+    attr_reader :date
+
+    ##
+    # Parse a string to a Date or EDTF::Date using rules appropriate to the
+    # given encoding
+    # @param [String] text
+    # @return [Date]
+    def self.parse_date(text)
+      ::Date.edtf(cleanup(text))
+    end
+
+    ##
+    # Apply any encoding-specific munging or text extraction logic
+    # @param [String] text
+    # @return [String]
+    def self.cleanup(text)
+      text.gsub(/^[\[]+/, '').gsub(/[\.\]]+$/, '')
+    end
+
+    def initialize(xml)
+      @xml = xml
+      @date = self.class.parse_date(xml.text)
+    end
+
+    ##
+    # Return a range, with the min point as the earliest possible date and
+    # the max as the latest possible date (useful particularly for ranges and uncertainty)
+    #
+    # @param [Range]
+    def as_range
+      return unless earliest_date && latest_date
+
+      earliest_date..latest_date
+    end
+
+    ##
+    # Return an array of all years that fall into the range of possible dates
+    # covered by the data. Note that some encodings support disjoint sets of ranges
+    # so this method could provide more accuracy than #as_range (although potentially)
+    # include a really big list of dates
+    #
+    # @return [Array]
+    def to_a
+      case date
+      when EDTF::Set
+        date.to_a
+      else
+        as_range.to_a
+      end
+    end
+
+    ##
+    # The text as encoded in the MODS
+    # @return [String]
+    def text
+      xml.text
+    end
+
+    ##
+    # The declared type of date (from the MODS @type attribute)
+    #
+    # @return [String]
+    def type
+      xml.attr(:type)
+    end
+
+    ##
+    # The declared encoding of date (from the MODS @encoding attribute)
+    #
+    # @return [String]
+    def encoding
+      xml.attr(:encoding)
+    end
+
+    ##
+    # Was an encoding provided?
+    #
+    # @return [Boolean]
+    def encoding?
+      !encoding.nil?
+    end
+
+    ##
+    # The declared point of date (from the MODS @point attribute)
+    #
+    # @return [String]
+    def point
+      xml.attr(:point)
+    end
+
+    ##
+    # Is this date stand-alone, or part of a MODS-encoded range?
+    #
+    # @return [Boolean]
+    def single?
+      point.nil?
+    end
+
+    ##
+    # Is this date the start of a MODS-encoded range?
+    #
+    # @return [Boolean]
+    def start?
+      point == 'start'
+    end
+
+    ##
+    # Is this date the end point of a MODS-encoded range?
+    #
+    # @return [Boolean]
+    def end?
+      point == 'end'
+    end
+
+    ##
+    # The declared qualifier of date (from the MODS @qualifier attribute)
+    #
+    # @return [String]
+    def qualifier
+      xml.attr(:qualifier)
+    end
+
+    ##
+    # Is the date declared as an approximate date?
+    #
+    # @return [Boolean]
+    def approximate?
+      qualifier == 'approximate'
+    end
+
+    ##
+    # Is the date declared as an inferred date?
+    #
+    # @return [Boolean]
+    def inferred?
+      qualifier == 'inferred'
+    end
+
+    ##
+    # Is the date declared as a questionable date?
+    #
+    # @return [Boolean]
+    def questionable?
+      qualifier == 'questionable'
+    end
+
+    private
+
+    def days_in_month(month, year)
+      if month == 2 && ::Date.gregorian_leap?(year)
+        29
+      else
+        [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month]
+      end
+    end
+
+    ##
+    # Return the earliest possible date that is encoded in the data, respecting
+    # unspecified or imprecise information.
+    #
+    # @return [::Date]
+    def earliest_date
+      return nil if date.nil?
+
+      case date_range
+      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
+      end
+    end
+
+    ##
+    # Return the earliest possible date that is encoded in the data, respecting
+    # unspecified or imprecise information.
+    #
+    # @return [::Date]
+    def latest_date
+      return nil if date.nil?
+      case date_range
+      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
+      end
+    end
+
+    def date_range
+      @date_range ||= if text =~ /u/
+        ::Date.edtf(text.gsub('u', 'X')) || date
+      else
+        date
+      end
+    end
+  end
+end

data/lib/mods/nom_terminology.rb

@@ -285,6 +285,7 @@ module Mods
         # ORIGIN_INFO --------------------------------------------------------------------------
         t.origin_info :path => '/m:mods/m:originInfo'
         t._origin_info :path => '//m:originInfo' do |n|
+          n.as_object :path => '.', :accessor => lambda { |a| Mods::OriginInfo.new(a) }
           # attributes
           n.displayLabel :path => '@displayLabel', :accessor => lambda { |a| a.text }
           Mods::LANG_ATTRIBS.each { |attr_name|
@@ -300,8 +301,10 @@ module Mods
             end
           end
           n.publisher :path => 'm:publisher'
-          Mods::ORIGIN_INFO_DATE_ELEMENTS.each { |date_el|
+          Mods::OriginInfo::DATE_ELEMENTS.each { |date_el|
             n.send date_el, :path => "m:#{date_el}" do |d|
+              d.as_object :path => '.', :accessor => lambda { |a| Mods::Date.from_element(a) }
+
               Mods::DATE_ATTRIBS.each { |attr_name|
                 d.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
               }
@@ -912,7 +915,7 @@ module Mods
             end
           end
           n.publisher :path => 'publisher'
-          Mods::ORIGIN_INFO_DATE_ELEMENTS.each { |date_el|
+          Mods::OriginInfo::DATE_ELEMENTS.each { |date_el|
             n.send date_el, :path => "#{date_el}" do |d|
               Mods::DATE_ATTRIBS.each { |attr_name|
                 d.send attr_name, :path => "@#{attr_name}", :accessor => lambda { |a| a.text }
@@ -1241,4 +1244,3 @@ module Mods
 
   end # Record class
 end # Mods module
-

data/lib/mods/origin_info.rb

@@ -0,0 +1,19 @@
+module Mods
+  class OriginInfo
+    DATE_ELEMENTS = ['dateIssued', 'dateCreated', 'dateCaptured', 'dateValid', 'dateModified', 'copyrightDate', 'dateOther']
+
+    attr_reader :xml
+
+    def initialize(xml)
+      @xml = xml
+    end
+
+    def dates
+      DATE_ELEMENTS.flat_map { |element| xml.public_send(element) }
+    end
+
+    def key_dates
+      dates.select { |x| x.keyDate == 'yes' }
+    end
+  end
+end

data/lib/mods/version.rb

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

data/mods.gemspec

@@ -15,10 +15,11 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^spec/})
   gem.require_paths = ["lib"]
-  
+
   gem.add_dependency 'nokogiri'
   gem.add_dependency 'nom-xml', '~> 0.6.0'
   gem.add_dependency 'iso-639'
+  gem.add_dependency 'edtf'
 
   # Runtime dependencies
   # gem.add_runtime_dependency 'nokogiri'

data/spec/date_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+RSpec.describe Mods::Date do
+  subject(:date) { described_class.from_element(term) }
+  let(:term) { Nokogiri::XML.fragment(date_element).first_element_child }
+
+  describe '#to_a' do
+    context 'with EDTF encoded sets' do
+      let(:date_element) { "<dateCreated encoding=\"edtf\">[1667,1668,1670..1672]</dateCreated>" }
+
+      it 'returns the list of years' do
+        expect(date.to_a.map(&:year)).to match_array [1667, 1668, 1670, 1671, 1672]
+      end
+    end
+
+    context 'with EDTF encoded ranges' do
+      let(:date_element) { "<dateCreated encoding=\"edtf\">1856/1858</dateCreated>" }
+
+      it 'returns the list of years' do
+        expect(date.to_a.map(&:year)).to match_array [1856, 1857, 1858]
+      end
+    end
+
+    context 'with random one-off years' do
+      let(:date_element) { "<dateCreated>1856</dateCreated>" }
+
+      it 'returns the year in an array' do
+        expect(date.to_a.map(&:year)).to match_array [1856]
+      end
+    end
+  end
+
+  describe '#text' do
+    let(:date_element) { "<dateCreated>1856</dateCreated>" }
+
+    it 'returns the MODS text' do
+      expect(date.text).to eq '1856'
+    end
+  end
+
+  describe '#type' do
+    let(:date_element) { "<dateCreated type='fictional'>1856</dateCreated>" }
+
+    it 'returns the MODS type attribute' do
+      expect(date.type).to eq 'fictional'
+    end
+  end
+
+  describe '#encoding' do
+    let(:date_element) { "<dateCreated encoding='fictional'>1856</dateCreated>" }
+
+    it 'returns the MODS encoding attribute' do
+      expect(date.encoding).to eq 'fictional'
+    end
+  end
+
+  describe '#encoding?' do
+    context 'with an encoding' do
+      let(:date_element) { "<dateCreated encoding='fictional'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.encoding?).to eq true
+      end
+    end
+
+    context 'without an encoding' do
+      let(:date_element) { "<dateCreated>1856</dateCreated>" }
+
+      it 'returns false' do
+        expect(date.encoding?).to eq false
+      end
+    end
+  end
+
+  describe '#point' do
+    let(:date_element) { "<dateCreated point='fictional'>1856</dateCreated>" }
+
+    it 'returns the MODS point attribute' do
+      expect(date.point).to eq 'fictional'
+    end
+  end
+
+  describe '#single?' do
+    context 'with a point' do
+      let(:date_element) { "<dateCreated point='fictional'>1856</dateCreated>" }
+
+      it 'returns false' do
+        expect(date.single?).to eq false
+      end
+    end
+
+    context 'without a point' do
+      let(:date_element) { "<dateCreated>1856</dateCreated>" }
+
+      it 'returns false' do
+        expect(date.single?).to eq true
+      end
+    end
+  end
+
+  describe '#start?' do
+    context 'with a point=start attribute' do
+      let(:date_element) { "<dateCreated point='start'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.start?).to eq true
+      end
+    end
+  end
+
+  describe '#end?' do
+    context 'with a point=end attribute' do
+      let(:date_element) { "<dateCreated point='end'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.end?).to eq true
+      end
+    end
+  end
+
+  describe '#qualifier' do
+    let(:date_element) { "<dateCreated qualifier='fictional'>1856</dateCreated>" }
+
+    it 'returns the MODS qualifier attribute' do
+      expect(date.qualifier).to eq 'fictional'
+    end
+  end
+
+  describe '#approximate?' do
+    context 'with a qualifier=approximate attribute' do
+      let(:date_element) { "<dateCreated qualifier='approximate'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.approximate?).to eq true
+      end
+    end
+  end
+
+  describe '#inferred?' do
+    context 'with a qualifier=inferred attribute' do
+      let(:date_element) { "<dateCreated qualifier='inferred'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.inferred?).to eq true
+      end
+    end
+  end
+
+  describe '#questionable?' do
+    context 'with a qualifier=questionable attribute' do
+      let(:date_element) { "<dateCreated qualifier='questionable'>1856</dateCreated>" }
+
+      it 'returns true' do
+        expect(date.questionable?).to eq true
+      end
+    end
+  end
+
+  describe 'EDTF encoded dates' do
+    {
+      '1905' => Date.parse('1905-01-01')..Date.parse('1905-12-31'),
+      '190u' => Date.parse('1900-01-01')..Date.parse('1909-12-31'),
+      '190X' => Date.parse('1900-01-01')..Date.parse('1909-12-31'),
+      '19uu' => Date.parse('1900-01-01')..Date.parse('1999-12-31'),
+      '19XX' => Date.parse('1900-01-01')..Date.parse('1999-12-31'),
+      '1856/1876' => Date.parse('1856-01-01')..Date.parse('1876-12-31'),
+      '[1667,1668,1670..1672]' => Date.parse('1667-01-01')..Date.parse('1672-12-31'),
+      '1900-uu' => Date.parse('1900-01-01')..Date.parse('1900-12-31'),
+      '1900-uu-uu' => Date.parse('1900-01-01')..Date.parse('1900-12-31'),
+      '1900-uu-15' => Date.parse('1900-01-15')..Date.parse('1900-12-15'),
+      '1900-06-uu' => Date.parse('1900-06-01')..Date.parse('1900-06-30'),
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated encoding=\"edtf\">#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.encoding).to eq 'edtf'
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'W3cdtf encoded dates' do
+    {
+      '1753' => Date.parse('1753-01-01')..Date.parse('1753-12-31'),
+      '-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')
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated encoding=\"w3cdtf\">#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.encoding).to eq 'w3cdtf'
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'MARC encoded dates' 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')
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated encoding=\"marc\">#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.encoding).to eq 'marc'
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'ISO8601 encoded dates' do
+    {
+      '20131114161429' => Date.parse('20131114161429')..Date.parse('20131114161429')
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated encoding=\"iso8601\">#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.encoding).to eq 'iso8601'
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'MDY encoded dates' do
+    {
+      '11/27/2017' => Date.parse('2017-11-27')..Date.parse('2017-11-27'),
+      '5/27/2017' => Date.parse('2017-05-27')..Date.parse('2017-05-27'),
+      '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')
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated>#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'Pulling out 4-digit years from unspecified dates' do
+    {
+      'Minguo 19 [1930]' => Date.parse('1930-01-01')..Date.parse('1930-12-31'),
+      '1745 mag. 14' => Date.parse('1745-01-01')..Date.parse('1745-12-31'),
+      '-745' => Date.parse('-745-01-01')..Date.parse('-745-12-31'),
+      '[1923]' => Date.parse('1923-01-01')..Date.parse('1923-12-31'),
+      '1532.' => Date.parse('1532-01-01')..Date.parse('1532-12-31'),
+      '[ca 1834]' => Date.parse('1834-01-01')..Date.parse('1834-12-31'),
+      'xvi' => Date.parse('1500-01-01')..Date.parse('1599-12-31'),
+      'cent. xvi' => Date.parse('1500-01-01')..Date.parse('1599-12-31'),
+      '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')
+    }.each do |data, expected|
+      describe "with #{data}" do
+        let(:date_element) { "<dateCreated>#{data}</dateCreated>" }
+
+        it "has the range #{expected}" do
+          expect(date).to be_single
+          expect(date.as_range.to_s).to eq expected.to_s
+        end
+      end
+    end
+  end
+
+  describe 'garbage data' do
+    let(:date_element) { "<dateCreated>n.d.</dateCreated>" }
+
+    it 'handles it gracefully' do
+      expect(date.as_range).to be_nil
+      expect(date.to_a).to be_empty
+      expect(date.text).to eq 'n.d.'
+    end
+
+    context 'for dates with encodings declared, but invalid data' do
+      let(:date_element) { "<dateCreated encoding='iso8601'>n.d.</dateCreated>" }
+
+      it 'handles it gracefully' do
+        expect(date.as_range).to be_nil
+        expect(date.to_a).to be_empty
+        expect(date.text).to eq 'n.d.'
+      end
+    end
+  end
+end

data/spec/origin_info_spec.rb

@@ -243,6 +243,15 @@ describe "Mods <originInfo> Element" do
         end
       end
 
+      describe '#as_object' do
+        describe '#key_dates' do
+          it 'should extract the date with the keyDate attribute' do
+            @mods_rec.from_str("<mods #{@ns_decl}><originInfo><dateCreated>other date</dateCreated><dateCreated keyDate='yes'>key date</dateCreated></originInfo></mods>")
+            expect(@mods_rec.origin_info.as_object.first.key_dates.first.text).to eq 'key date'
+          end
+        end
+      end
+
       context "<xxxDate> child elements" do
         it "should recognize each element" do
           Mods::ORIGIN_INFO_DATE_ELEMENTS.each { |elname|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mods
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Naomi Dushay
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2017-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -53,6 +53,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: edtf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -145,17 +159,20 @@ files:
 - Rakefile
 - lib/mods.rb
 - lib/mods/constants.rb
+- lib/mods/date.rb
 - lib/mods/marc_country_codes.rb
 - lib/mods/marc_geo_area_codes.rb
 - lib/mods/marc_relator_codes.rb
 - lib/mods/name.rb
 - lib/mods/nom_terminology.rb
+- lib/mods/origin_info.rb
 - lib/mods/reader.rb
 - lib/mods/record.rb
 - lib/mods/subject.rb
 - lib/mods/title_info.rb
 - lib/mods/version.rb
 - mods.gemspec
+- spec/date_spec.rb
 - spec/fixture_data/shpc1.mods.xml
 - spec/language_spec.rb
 - spec/location_spec.rb
@@ -190,11 +207,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Parse MODS (Metadata Object Description Schema) records.
 test_files:
+- spec/date_spec.rb
 - spec/fixture_data/shpc1.mods.xml
 - spec/language_spec.rb
 - spec/location_spec.rb