stanford-mods 3.0.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70d3b7093c830baa3c12f4c2c438549eb451fa4b6bb6c57f458382f0e8e53dc2
-  data.tar.gz: 044edaeef524c4a701ebbc0e25f08d0c3fb5068b04cc36ab8769772004a73a85
+  metadata.gz: c9c63c6699eef72da80bbf9e15d892248dfc21a7550588aac09843ef26d1869f
+  data.tar.gz: f820451452017ec653c4eabd48d19cb23a36fcfafbad814272dd26c9cc9b9d42
 SHA512:
-  metadata.gz: '097830e7c3b1136a279dfce41ac426ae860ab020f27bb1550a3f2a5f23b7fcbc1c7f7952f35f06a44aed7100d0d410c39adcbb17a70b270174c85b757d1aca4b'
-  data.tar.gz: 7aa1c33f53fdbd4160d99a14739b4dcbd37950f4d8ab8238ee1886d4b6db4aaa9b5dec4c92f74842db80aa9839ec2d7e27a570a4fb7cde4862afc54b79c9e6a4
+  metadata.gz: '0817296bebb438d882509919ff0b6fb2ec0e1accd71b379209f3b3b5f4cbd684d8208d8aab7ff3ce5f745860c4331af9098afadb5d066bd406016625c63d3701'
+  data.tar.gz: 4ed8b47a3186c3f241d2b543358138c71bea5f7128fc483e1d78117af1224b75db1fb4524763c726b011f414524b7d732a54096dd07d38a909c13a05116cc3ca

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
-      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
-
-          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
+      # @note for sorting:  5 BCE => -5;  666 BCE => -666
+      def pub_year_int(ignore_approximate: false)
+        date = earliest_preferred_date(ignore_approximate: ignore_approximate)
+
+        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
+      def pub_year_sort_str(ignore_approximate: false)
+        earliest_preferred_date(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
+      def pub_year_display_str(ignore_approximate: false)
+        earliest_preferred_date(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/coordinate.rb

@@ -65,11 +65,14 @@ module Stanford
       # @param [String] point coordinate point in degrees notation
       # @return [Float] converted value in decimal notation
       def coord_to_decimal(point)
-        regex = /(?<dir>[NESW])\s*(?<deg>\d+)[°⁰º](?:(?<min>\d+)[ʹ'])?(?:(?<sec>\d+)[ʺ"])?/
+        regex = Regexp.union(
+          /(?<dir>[NESW])\s*(?<deg>\d+)[°⁰º](?:(?<min>\d+)[ʹ'])?(?:(?<sec>\d+)[ʺ"])?/,
+          /^\s*(?<dir>[NESW])\s*(?<deg>\d+(?:[.]\d+)?)\s*$/
+        )
         match = regex.match(point)
         return Float::INFINITY unless match
 
-        dec = match['deg'].to_i
+        dec = match['deg'].to_f
         dec += match['min'].to_f / 60
         dec += match['sec'].to_f / 60 / 60
         dec = -1 * dec if match['dir'] == 'W' || match['dir'] == 'S'

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,26 +147,87 @@ 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
 
-          # Delegate to the appropriate decoding method, if any
-          case value.precision
+          if date.is_a?(EDTF::Interval)
+            if value.precision == :century || value.precision == :decade
+              return format_date(date, value.precision, allowed_precisions)
+            end
+
+            range = [
+              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, allowed_precisions) || text.strip
+          end
+        end
+
+        # 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')
           when :month
@@ -175,41 +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 :century
-            return "#{(date.to_s[0..1].to_i + 1).ordinalize} century"
           when :decade
-            return "#{date.year}s"
-          else
-            text.strip
+            "#{date.year}s"
+          when :century
+            if date.year.negative?
+              "#{((date.year / 100).abs + 1).ordinalize} century BCE"
+            else
+              "#{((date.year / 100) + 1).ordinalize} century"
+            end
           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
-          date = decoded_value
-
-          return "[ca. #{date}]" if qualifier == 'approximate'
-          return "[#{date}?]" if qualifier == 'questionable'
-          return "[#{date}]" if qualifier == 'inferred'
-
-          date
+          qualified_format = case qualifier
+                             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}"
@@ -225,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'
@@ -245,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?
@@ -279,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.0.0'.freeze
+    VERSION = '3.3.0'.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>