stanford-mods 3.1.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22cc1cc8aafefb053ea3856e273e17be7089862160e91d87c483393b60c02aca
-  data.tar.gz: dbeea673e2c79744215c278ebf2fa73b78de3de7f79602590948bf4ee117b1df
+  metadata.gz: f4b93a6a17a1d2d60d82a661d02d6ba4a74f6c9958597a9895650506b4f4c4b1
+  data.tar.gz: a63b8a8a5bd2c6b638082936e5ee908613cb981447b016e6b8d3beed8c2637b8
 SHA512:
-  metadata.gz: fb3d7b5761a6e4811dd85b6d4972ce238e5b507e957d617b5e4a3935bcd3e9f791176d250418a198d2b68a63babfc58dcb9c39d1b8b4fbbbdd01eecc504fa8a2
-  data.tar.gz: 3fe0f6181376c4cca9618a90e9a03244328f3a93a16ea55f1b5a72c7f842ddd0de8addbfb2da75efa4875bc4c04e4dd73caaad543745faf9461da7928566487e
+  metadata.gz: b61ce90be97c3b7b314f5b2a199f18bbb8843c8de704703a71a55540241ee4aa3307b1683b0c6b60de170de781d08cb702233cef1626a69af09bd78dc8590253
+  data.tar.gz: 1fcc5a1238cab589e41ee281dad172c24adea68b718401a643bcc71e138b0623a8d54717fb89204cf708e014b0dfc638a5fb307dd2bf5716e6fb74bfb84087f1

data/lib/stanford-mods/concerns/origin_info.rb

@@ -15,15 +15,23 @@ module Stanford
       #  look for a keyDate and use it if there is one;  otherwise pick earliest date
       # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute) should be ignored; false if approximate dates should be included
       # @return [Integer] publication year as an Integer
-      # @note for sorting:  5 B.C. => -5;  666 B.C. => -666
+      # @note for sorting:  5 BCE => -5;  666 BCE => -666
       def pub_year_int(fields = [:dateIssued, :dateCreated, :dateCaptured], ignore_approximate: false)
-        fields.each do |date_key|
-          values = mods_ng_xml.origin_info.send(date_key)
-          values = values.reject(&method(:is_approximate)) if ignore_approximate
+        date = earliest_preferred_date(fields: fields, ignore_approximate: ignore_approximate)
 
-          earliest_date = Stanford::Mods::OriginInfo.best_or_earliest_year(values)
-          return earliest_date.year_int_from_date_str if earliest_date&.year_int_from_date_str
-        end; nil
+        return unless date
+
+        if date.is_a? Stanford::Mods::Imprint::DateRange
+          date = date.start || date.stop
+        end
+
+        edtf_date = date.date
+
+        if edtf_date.is_a?(EDTF::Interval)
+          edtf_date.from.year
+        else
+          edtf_date.year
+        end
       end
 
       # return a single string intended for lexical sorting for pub date
@@ -31,39 +39,19 @@ module Stanford
       #  look for a keyDate and use it if there is one;  otherwise pick earliest date
       # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute) should be ignored; false if approximate dates should be included
       # @return [String] single String containing publication year for lexical sorting
-      # @note for string sorting  5 B.C. = -5  => -995;  6 B.C. => -994, so 6 B.C. sorts before 5 B.C.
+      # @note for string sorting  5 BCE = -5  => -995;  6 BCE => -994, so 6 BCE sorts before 5 BCE
       # @deprecated use pub_year_int
       def pub_year_sort_str(fields = [:dateIssued, :dateCreated, :dateCaptured], ignore_approximate: false)
-        fields.each do |date_key|
-          values = mods_ng_xml.origin_info.send(date_key)
-          values = values.reject(&method(:is_approximate)) if ignore_approximate
-
-          earliest_date = Stanford::Mods::OriginInfo.best_or_earliest_year(values)
-          return earliest_date.sortable_year_string_from_date_str if earliest_date&.sortable_year_string_from_date_str
-        end; nil
+        earliest_preferred_date(fields: fields, ignore_approximate: ignore_approximate)&.sort_key
       end
 
-      # return a single string intended for display of pub year
-      # 0 < year < 1000:  add A.D. suffix
-      # year < 0:  add B.C. suffix.  ('-5'  =>  '5 B.C.', '700 B.C.'  => '700 B.C.')
-      # 195u =>  195x
-      # 19uu => 19xx
-      #   '-5'  =>  '5 B.C.'
-      #   '700 B.C.'  => '700 B.C.'
-      #   '7th century' => '7th century'
-      # date ranges?
-      # prefer dateIssued (any) before dateCreated (any) before dateCaptured (any)
-      #  look for a keyDate and use it if there is one;  otherwise pick earliest date
+      # return a single string intended for display of pub year (or year range)
+      #
+      # @param [Array<Symbol>] fields array of field types to use to look for dates.
       # @param [Boolean] ignore_approximate true if approximate dates (per qualifier attribute)
       #   should be ignored; false if approximate dates should be included
       def pub_year_display_str(fields = [:dateIssued, :dateCreated, :dateCaptured], ignore_approximate: false)
-        fields.each do |date_key|
-          values = mods_ng_xml.origin_info.send(date_key)
-          values = values.reject(&method(:is_approximate)) if ignore_approximate
-
-          earliest_date = Stanford::Mods::OriginInfo.best_or_earliest_year(values)
-          return earliest_date.date_str_for_display if earliest_date&.date_str_for_display
-        end; nil
+        earliest_preferred_date(fields: fields, ignore_approximate: ignore_approximate)&.decoded_value(allowed_precisions: [:year, :decade, :century], ignore_unparseable: true, display_original_text: false)
       end
 
       # @return [Array<Stanford::Mods::Imprint>] array of imprint objects
@@ -81,32 +69,39 @@ module Stanford
         imprints.map(&:display_str).reject(&:empty?).join('; ')
       end
 
-      # remove Elements from NodeSet if they have a qualifier attribute of 'approximate' or 'questionable'
-      # @param [Nokogiri::XML::Element] node the date element
-      # @return [Boolean]
-      # @private
-      def is_approximate(node)
-        qualifier = node["qualifier"] if node.respond_to?('[]')
-        qualifier == 'approximate' || qualifier == 'questionable'
-      end
+      private
+
+      # The rules for which date to pick is a little complicated:
+      #
+      # 1) Examine the date elements of the provided fields.
+      # 2) Discard any we can't parse a year out of.
+      # 3) (if ignore_approximate is true, used only by exhibits for Feigenbaum), throw out any qualified dates (or ranges if either the start or end is qualified)
+      # 4) If that set of date elements has elements with a keyDate, prefer those.
+      # 5) If there were encoded dates, prefer those.
+      # 6) Choose the earliest date (or starting date of a range).
+      #
+      # Finally, format the date or range of an encoded date, or just pluck out the year from an unencoded one.
+      def earliest_preferred_date(fields: [:dateIssued, :dateCreated, :dateCaptured], ignore_approximate: false)
+        local_imprints = imprints
+
+        fields.each do |field_name|
+          potential_dates = local_imprints.flat_map do |imprint|
+            dates = imprint.dates([field_name])
+            dates = dates.select(&:parsed_date?)
+            dates = dates.reject(&:qualified?) if ignore_approximate
+
+            dates
+          end
 
-      # get earliest parseable year from the passed date elements
-      # @param [Array<Nokogiri::XML::Element>] date_el_array the elements from which to select a pub date
-      # @return [Stanford::Mods::DateParsing]
-      def self.best_or_earliest_year(date_el_array)
-        key_dates, other_dates = date_el_array.partition { |node| node['keyDate'] == 'yes' }
+          preferred_dates = potential_dates.select(&:key_date?).presence || potential_dates
+          best_dates = (preferred_dates.select { |x| x.encoding.present? }.presence || preferred_dates)
 
-        sortable_dates = key_dates.map { |x| DateParsing.new(x) }.select(&:sortable_year_string_from_date_str)
-        sortable_dates = other_dates.map { |x| DateParsing.new(x) }.select(&:sortable_year_string_from_date_str) if sortable_dates.empty?
-        results = {}
+          earliest_date = best_dates.min_by(&:sort_key)
 
-        # this is a little weird; instead of just the earliest sorting date, if there are multiple
-        # dates with the same sort key, we want to make sure we get the last occurring one?
-        sortable_dates.each do |v|
-          results[v.sortable_year_string_from_date_str] = v
+          return earliest_date if earliest_date
         end
 
-        results[results.keys.min]
+        nil
       end
     end # class Record
   end

data/lib/stanford-mods/imprint.rb

@@ -35,6 +35,17 @@ module Stanford
         ed_place_pub_dates
       end
 
+      # array of parsed but unformattted date values, for a given list of
+      # elements to pull data from
+      def dates(date_field_keys = [:dateIssued, :dateCreated, :dateCaptured, :copyrightDate])
+        date_field_keys.map do |date_field|
+          next unless element.respond_to?(date_field)
+
+          date_elements = element.send(date_field)
+          parse_dates(date_elements) if date_elements.present?
+        end.compact.flatten
+      end
+
       private
 
       def compact_and_join_with_delimiter(values, delimiter)
@@ -117,22 +128,10 @@ module Stanford
       # DATE processing methods ------
 
       def date_str
-        date_vals = origin_info_date_vals
+        date_vals = unique_dates_for_display(dates).map(&:qualified_value)
         return if date_vals.empty?
-        date_vals.map(&:strip).join(' ')
-      end
-
-      def origin_info_date_vals
-        date_field_keys.map do |date_field|
-          next unless element.respond_to?(date_field)
-
-          date_elements = element.send(date_field)
-          parse_dates(date_elements) if date_elements.present?
-        end.compact.flatten
-      end
 
-      def date_field_keys
-        [:dateIssued, :dateCreated, :dateCaptured, :copyrightDate]
+        date_vals.map(&:strip).join(' ')
       end
 
       class DateValue
@@ -148,43 +147,86 @@ module Stanford
           text.present? && !['9999', '0000-00-00', 'uuuu'].include?(text.strip)
         end
 
+        def key_date?
+          value.key?
+        end
+
+        def qualified?
+          qualifier.present?
+        end
+
+        def parsed_date?
+          date.present?
+        end
+
+        def sort_key
+          year = if date.is_a?(EDTF::Interval)
+            date.from.year
+          else
+            date.year
+          end
+
+          str = if year < 1
+            (-1 * year - 1000).to_s
+          else
+            year.to_s
+          end
+
+          case value.precision
+          when :decade
+            str[0..2] + "-"
+          when :century
+            str[0..1] + "--"
+          else
+            str.rjust(4, "0")
+          end
+        end
+
         # Element text reduced to digits and hyphen. Captures date ranges and
-        # negative (B.C.) dates. Used for comparison/deduping.
+        # negative (BCE) dates. Used for comparison/deduping.
         def base_value
           if text =~ /^\[?1\d{3}-\d{2}\??\]?$/
             return text.sub(/(\d{2})(\d{2})-(\d{2})/, '\1\2-\1\3')
           end
 
-          text.gsub(/(?<![\d])(\d{1,3})([xu-]{1,3})/i) { "#{$1}#{'0' * $2.length}"}.scan(/[\d-]/).join
+          text.gsub(/(?<![\d])(\d{1,3})([xu-]{1,3})/i) { "#{Regexp.last_match(1)}#{'0' * Regexp.last_match(2).length}" }.scan(/[\d-]/).join
         end
 
         # Decoded version of the date, if it was encoded. Strips leading zeroes.
-        def decoded_value
+        def decoded_value(allowed_precisions: [:day, :month, :year, :decade, :century], ignore_unparseable: false, display_original_text: true)
+          return if ignore_unparseable && !date
           return text.strip unless date
 
-          unless encoding.present?
-            return text.strip unless text =~ /^-?\d+$/ || text =~ /^[\dXxu?-]{4}$/
+          if display_original_text
+            unless encoding.present?
+              return text.strip unless text =~ /^-?\d+$/ || text =~ /^[\dXxu?-]{4}$/
+            end
           end
 
           if date.is_a?(EDTF::Interval)
             if value.precision == :century || value.precision == :decade
-              return format_date(date, value.precision)
+              return format_date(date, value.precision, allowed_precisions)
             end
 
             range = [
-              format_date(date.min, date.min.precision),
-              format_date(date.max, date.max.precision)
+              format_date(date.min, date.min.precision, allowed_precisions),
+              format_date(date.max, date.max.precision, allowed_precisions)
             ].uniq.compact
 
             return text.strip if range.empty?
 
             range.join(' - ')
           else
-            format_date(date, value.precision) || text.strip
+            format_date(date, value.precision, allowed_precisions) || text.strip
           end
         end
 
-        def format_date(date, precision)
+        # Returns the date in the format specified by the precision.
+        # Allowed_precisions should be ordered by granularity and supports e.g.
+        # getting a year precision when the actual date is more precise.
+        def format_date(date, precision, allowed_precisions)
+          precision = allowed_precisions.first unless allowed_precisions.include?(precision)
+
           case precision
           when :day
             date.strftime('%B %e, %Y')
@@ -193,48 +235,54 @@ module Stanford
           when :year
             year = date.year
             if year < 1
-              "#{year.abs + 1} B.C."
-            # Any dates before the year 1000 are explicitly marked A.D.
+              "#{year.abs + 1} BCE"
+            # Any dates before the year 1000 are explicitly marked CE
             elsif year > 1 && year < 1000
-              "#{year} A.D."
+              "#{year} CE"
             else
               year.to_s
             end
+          when :decade
+            "#{date.year}s"
           when :century
             if date.year.negative?
-              "#{((date.year / 100).abs + 1).ordinalize} century B.C."
+              "#{((date.year / 100).abs + 1).ordinalize} century BCE"
             else
               "#{((date.year / 100) + 1).ordinalize} century"
             end
-          when :decade
-            "#{date.year}s"
           end
         end
 
-        # Decoded date with "B.C." or "A.D." and qualifier markers. See (outdated):
+        # Decoded date with "BCE" or "CE" and qualifier markers. See (outdated):
         # https://consul.stanford.edu/display/chimera/MODS+display+rules#MODSdisplayrules-3b.%3CoriginInfo%3E
         def qualified_value
           qualified_format = case qualifier
-          when 'approximate'
-            '[ca. %s]'
-          when 'questionable'
-            '[%s?]'
-          when 'inferred'
-            '[%s]'
-          else
-            '%s'
-          end
+                             when 'approximate'
+                               '[ca. %s]'
+                             when 'questionable'
+                               '[%s?]'
+                             when 'inferred'
+                               '[%s]'
+                             else
+                               '%s'
+                             end
 
           format(qualified_format, decoded_value)
         end
       end
 
       class DateRange
+        attr_reader :start, :stop
+
         def initialize(start: nil, stop: nil)
           @start = start
           @stop = stop
         end
 
+        def sort_key
+          @start&.sort_key || @stop&.sort_key
+        end
+
         # Base value as hyphen-joined string. Used for comparison/deduping.
         def base_value
           "#{@start&.base_value}-#{@stop&.base_value}"
@@ -250,12 +298,34 @@ module Stanford
           @start&.encoding || @stop&.encoding
         end
 
-        # Decoded dates with "B.C." or "A.D." and qualifier markers applied to
+        # If either date in the range is qualified in any way
+        def qualified?
+          @start&.qualified? || @stop&.qualified?
+        end
+
+        # If either date in the range is a key date
+        def key_date?
+          @start&.key_date? || @stop&.key_date?
+        end
+
+        # If either date in the range was successfully parsed
+        def parsed_date?
+          @start&.parsed_date? || @stop&.parsed_date?
+        end
+
+        def decoded_value(**kwargs)
+          [
+            @start&.decoded_value(**kwargs),
+            @stop&.decoded_value(**kwargs)
+          ].uniq.join(' - ')
+        end
+
+        # Decoded dates with "BCE" or "CE" and qualifier markers applied to
         # the entire range, or individually if dates differ.
         def qualified_value
           if @start&.qualifier == @stop&.qualifier
             qualifier = @start&.qualifier || @stop&.qualifier
-            date = "#{@start&.decoded_value} - #{@stop&.decoded_value}"
+            date = decoded_value
             return "[ca. #{date}]" if qualifier == 'approximate'
             return "[#{date}?]" if qualifier == 'questionable'
             return "[#{date}]" if qualifier == 'inferred'
@@ -270,15 +340,19 @@ module Stanford
       def parse_dates(elements)
         # convert to DateValue objects and keep only valid ones
         dates = elements.map(&:as_object).flatten.map { |element| DateValue.new(element) }.select(&:valid?)
+
         # join any date ranges into DateRange objects
-        point, nonpoint = dates.partition(&:point)
-        if point.any?
-          range = DateRange.new(start: point.find { |date| date.point == 'start' },
-                                stop: point.find { |date| date.point == 'end' })
-          nonpoint.unshift(range)
+        point_dates, dates = dates.partition(&:point)
+        if point_dates.any?
+          range = DateRange.new(start: point_dates.find { |date| date.point == 'start' },
+                                stop: point_dates.find { |date| date.point == 'end' })
+          dates.unshift(range)
+        else
+          dates
         end
-        dates = nonpoint
+      end
 
+      def unique_dates_for_display(dates)
         # ensure dates are unique with respect to their base values
         dates = dates.group_by(&:base_value).map do |_value, group|
           next group.first if group.one?
@@ -304,10 +378,7 @@ module Stanford
           date_ranges.select { |r| r.base_values.include?(date.base_value) }
         end
 
-        dates = dates - duplicated_ranges
-
-        # output formatted dates with qualifiers, A.D./B.C., etc.
-        dates.map(&:qualified_value)
+        dates - duplicated_ranges
       end
     end
   end

data/lib/stanford-mods/version.rb

@@ -1,6 +1,6 @@
 module Stanford
   module Mods
     # this is the Ruby Gem version
-    VERSION = '3.1.0'.freeze
+    VERSION = '3.3.1'.freeze
   end
 end

data/lib/stanford-mods.rb

@@ -1,7 +1,6 @@
 require 'active_support'
 require 'active_support/core_ext/integer/inflections'
 require 'mods'
-require 'stanford-mods/date_parsing'
 require 'stanford-mods/coordinate'
 require 'stanford-mods/imprint'
 require 'stanford-mods/vocabularies/searchworks_languages'
@@ -18,4 +17,4 @@ require 'stanford-mods/version'
 module Stanford
   module Mods
   end
-end
+end

data/spec/fixtures/searchworks_imprint_data.rb

@@ -700,7 +700,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <dateIssued encoding="marc" point="start" keyDate="yes">0850</dateIssued>
         <dateIssued encoding="marc" point="end">1499</dateIssued>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => 'California, 850 A.D. - 1499',
+        mods_origin_info_end_str => 'California, 850 CE - 1499',
       # coll rec  bd001pp3337
       # coll rec fn508pj9953
       mods_origin_info_start_str +
@@ -728,7 +728,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <dateCreated point="start" qualifier="approximate" keyDate="yes">850</dateCreated>
         <dateCreated point="end" qualifier="approximate">1499</dateCreated>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => 'England, [ca. 850 A.D. - 1499]',
+        mods_origin_info_end_str => 'England, [ca. 850 CE - 1499]',
       # sc582cv9633
       mods_origin_info_start_str +
         '<dateCreated keydate="yes">1314</dateCreated>
@@ -1055,7 +1055,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <originInfo>
           <dateCreated encoding="edtf" point="start" keyDate="yes">-18</dateCreated>
           <dateCreated encoding="edtf" point="end">-17</dateCreated>' +
-        mods_origin_info_end_str => 'Spain; 19 B.C. - 18 B.C.',
+        mods_origin_info_end_str => 'Spain; 19 BCE - 18 BCE',
       # bb408km1389
       mods_origin_info_start_str +
         ' <place supplied="yes">
@@ -1065,7 +1065,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <originInfo>
           <dateCreated encoding="edtf" point="start" keyDate="yes">-1</dateCreated>
           <dateCreated encoding="edtf" point="end">11</dateCreated>' +
-        mods_origin_info_end_str => 'Lyon (France); 2 B.C. - 11 A.D.',
+        mods_origin_info_end_str => 'Lyon (France); 2 BCE - 11 CE',
       # cs470ng8064
       mods_origin_info_start_str +
         ' <place supplied="yes">
@@ -1075,7 +1075,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <originInfo>
           <dateCreated encoding="edtf" point="start" keyDate="yes">-1</dateCreated>
           <dateCreated encoding="edtf" point="end">0</dateCreated>' +
-        mods_origin_info_end_str => 'Antioch (Turkey) (?); 2 B.C. - 1 B.C.',
+        mods_origin_info_end_str => 'Antioch (Turkey) (?); 2 BCE - 1 BCE',
       # vh834jh5059
       mods_origin_info_start_str +
         ' <place supplied="yes">
@@ -1085,7 +1085,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <originInfo>
           <dateCreated encoding="edtf" point="start" keyDate="yes">13</dateCreated>
           <dateCreated encoding="edtf" point="end">14</dateCreated>' +
-        mods_origin_info_end_str => 'Lyon (France); 13 A.D. - 14 A.D.',
+        mods_origin_info_end_str => 'Lyon (France); 13 CE - 14 CE',
       # sk424bh9379
       mods_origin_info_start_str +
         ' <place supplied="yes">
@@ -1095,7 +1095,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <originInfo>
           <dateCreated encoding="edtf" point="start" keyDate="yes">34</dateCreated>
           <dateCreated encoding="edtf" point="end">35</dateCreated>' +
-        mods_origin_info_end_str => 'Alexandria (Egypt); 34 A.D. - 35 A.D.'
+        mods_origin_info_end_str => 'Alexandria (Egypt); 34 CE - 35 CE'
     },
   # rigler
   'rumsey' =>
@@ -1235,7 +1235,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         '<dateIssued encoding="marc" point="start">800</dateIssued>
         <dateIssued encoding="marc" point="end">1899</dateIssued>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => '800 A.D. - 1899',
+        mods_origin_info_end_str => '800 CE - 1899',
       # dc882bs3541
       mods_origin_info_start_str +
         '<place>
@@ -1245,7 +1245,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <dateCreated encoding="w3cdtf" point="end" qualifier="approximate">0799</dateCreated>
         <dateCreated encoding="w3cdtf" keyDate="yes"/>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => 'Egypt, [ca. 700 A.D. - 799 A.D.]',
+        mods_origin_info_end_str => 'Egypt, [ca. 700 CE - 799 CE]',
       # hg026ds6978
       mods_origin_info_start_str +
         '<place>
@@ -1253,7 +1253,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         </place>
         <dateCreated encoding="w3cdtf" keyDate="yes">0816</dateCreated>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => 'Central Arab lands, 816 A.D.',
+        mods_origin_info_end_str => 'Central Arab lands, 816 CE',
       # ch617yk2621
       mods_origin_info_start_str +
         '<place>
@@ -1273,7 +1273,7 @@ SEARCHWORKS_IMPRINT_DATA = {
         <dateCreated encoding="w3cdtf" point="end" qualifier="approximate">1000</dateCreated>
         <dateCreated encoding="w3cdtf" keyDate="yes"/>
         <issuance>monographic</issuance>' +
-        mods_origin_info_end_str => 'Byzantine Empire, [ca. 950 A.D. - 1000]',
+        mods_origin_info_end_str => 'Byzantine Empire, [ca. 950 CE - 1000]',
       # hj537kj5737
       mods_origin_info_start_str +
         '<dateIssued>15th century CE</dateIssued>

data/spec/imprint_spec.rb

@@ -108,7 +108,7 @@ describe Stanford::Mods::Imprint do
     it 'presents centuries' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
-          <dateIssued encoding="edtf">18XX</dateIssued>
+          <dateIssued encoding="edtf">18xx</dateIssued>
         #{mods_origin_info_end_str}
       XML
 
@@ -120,7 +120,7 @@ describe Stanford::Mods::Imprint do
     it 'presents decades' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
-          <dateIssued encoding="edtf">147X</dateIssued>
+          <dateIssued encoding="edtf">147x</dateIssued>
         #{mods_origin_info_end_str}
       XML
 
@@ -129,7 +129,7 @@ describe Stanford::Mods::Imprint do
       expect(updated_element).to eq '1470s'
     end
 
-    it 'adds A.D. to early years' do
+    it 'adds CE to early years' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
           <dateIssued encoding="edtf">988</dateIssued>
@@ -138,10 +138,10 @@ describe Stanford::Mods::Imprint do
 
       imp = stanford_mods_imprint(smods_rec)
       updated_element = imp.send(:date_str)
-      expect(updated_element).to eq '988 A.D.'
+      expect(updated_element).to eq '988 CE'
     end
 
-    it 'adds B.C. to B.C. years' do
+    it 'adds BCE to BCE years' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
           <dateIssued encoding="edtf">-5</dateIssued>
@@ -150,10 +150,10 @@ describe Stanford::Mods::Imprint do
 
       imp = stanford_mods_imprint(smods_rec)
       updated_element = imp.send(:date_str)
-      expect(updated_element).to eq '6 B.C.'
+      expect(updated_element).to eq '6 BCE'
     end
 
-    it 'has special handling for the year 0 (1 B.C.)' do
+    it 'has special handling for the year 0 (1 BCE)' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
           <dateIssued>0</dateIssued>
@@ -162,7 +162,7 @@ describe Stanford::Mods::Imprint do
 
       imp = stanford_mods_imprint(smods_rec)
       updated_element = imp.send(:date_str)
-      expect(updated_element).to eq '1 B.C.'
+      expect(updated_element).to eq '1 BCE'
     end
 
     it 'presents years + months' do
@@ -211,7 +211,7 @@ describe Stanford::Mods::Imprint do
 
       imp = stanford_mods_imprint(smods_rec)
       updated_element = imp.send(:date_str)
-      expect(updated_element).to eq '10th century B.C.'
+      expect(updated_element).to eq '10th century BCE'
     end
 
     it 'handles the approximate qualifier' do
@@ -235,13 +235,13 @@ describe Stanford::Mods::Imprint do
 
       imp = stanford_mods_imprint(smods_rec)
       updated_element = imp.send(:date_str)
-      expect(updated_element).to eq '[322 A.D.?]'
+      expect(updated_element).to eq '[322 CE?]'
     end
 
     it 'handles the inferred qualifier' do
       smods_rec.from_str <<-XML
         #{mods_origin_info_start_str}
-          <dateIssued encoding="edtf" qualifier="inferred">190X</dateIssued>
+          <dateIssued encoding="edtf" qualifier="inferred">190x</dateIssued>
         #{mods_origin_info_end_str}
       XML