stanford-mods 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57865ef64be3774919a58f9771243fb7f5090b09867fae098d3fa5ae6e2523cf
-  data.tar.gz: 1a09641f450a3739c9c61598ec4ad7a4f1f7b410c804d12df6d50530fb249cb7
+  metadata.gz: c9c63c6699eef72da80bbf9e15d892248dfc21a7550588aac09843ef26d1869f
+  data.tar.gz: f820451452017ec653c4eabd48d19cb23a36fcfafbad814272dd26c9cc9b9d42
 SHA512:
-  metadata.gz: c86f9171a032d1349068b43f6cf1272fbdf4a24419a58f66040132d7de2ea745853707b803608ea3344a137e544eff0e7e291a7b9c3922c09fe0568c68409a5e
-  data.tar.gz: d031a52bb328ae6efa0e42e7050fc4f990295509e4ee0a4b4c1f93f51b2412049b16c87091f27b95a02ed95be1278ccd5cbcc11771f59272bf77f82d73bd3bb2
+  metadata.gz: '0817296bebb438d882509919ff0b6fb2ec0e1accd71b379209f3b3b5f4cbd684d8208d8aab7ff3ce5f745860c4331af9098afadb5d066bd406016625c63d3701'
+  data.tar.gz: 4ed8b47a3186c3f241d2b543358138c71bea5f7128fc483e1d78117af1224b75db1fb4524763c726b011f414524b7d732a54096dd07d38a909c13a05116cc3ca

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

@@ -16,14 +16,22 @@ module Stanford
       # @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 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
-
-          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
+      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
@@ -33,37 +41,17 @@ module Stanford
       # @return [String] single String containing publication year for lexical sorting
       # @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 CE suffix
-      # year < 0:  add BCE suffix.  ('-5'  =>  '5 BCE', '700 BCE'  => '700 BCE')
-      # 195u =>  195x
-      # 19uu => 19xx
-      #   '-5'  =>  '5 BCE'
-      #   '700 BCE'  => '700 BCE'
-      #   '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/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,6 +147,41 @@ 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 (BCE) dates. Used for comparison/deduping.
         def base_value
@@ -155,36 +189,44 @@ module Stanford
             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')
@@ -200,14 +242,14 @@ module Stanford
             else
               year.to_s
             end
+          when :decade
+            "#{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
-          when :decade
-            "#{date.year}s"
           end
         end
 
@@ -215,26 +257,32 @@ module Stanford
         # 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
 
+        # 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, CE/BCE, 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.2.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