mods_display 1.0.0.alpha4 → 1.0.0.alpha5

data/lib/mods_display/fields/imprint.rb

@@ -1,44 +1,51 @@
+# frozen_string_literal: true
+
 module ModsDisplay
   class Imprint < Field
     include ModsDisplay::CountryCodes
+
     def fields
-      return_fields = []
-      @values.each do |value|
-        if imprint_display_form(value)
-          return_fields << imprint_display_form(value)
-        else
-          edition = edition_element(value)
-          place = place_element(value)
-          publisher = publisher_element(value)
-          parts = parts_element(value)
-          place_pub = compact_and_join_with_delimiter([place, publisher], ' : ')
-          edition_place = compact_and_join_with_delimiter([edition, place_pub], ' - ')
-          joined_place_parts = compact_and_join_with_delimiter([edition_place, parts], ', ')
-          unless joined_place_parts.empty?
-            return_fields << ModsDisplay::Values.new(
-              label: displayLabel(value) || I18n.t('mods_display.imprint'),
-              values: [joined_place_parts]
-            )
-          end
-          return_fields.concat(dates(value)) if dates(value).length > 0
-          if other_pub_info(value).length > 0
-            other_pub_info(value).each do |pub_info|
-              return_fields << ModsDisplay::Values.new(
-                label: displayLabel(value) || pub_info_labels[pub_info.name.to_sym],
-                values: [pub_info.text.strip]
-              )
-            end
-          end
+      collapse_fields(origin_info_data.flatten)
+    end
+
+    def origin_info_data
+      @values.map do |value|
+        return_fields = []
+
+        edition = edition_element(value)
+        place = place_element(value)
+        publisher = publisher_element(value)
+        parts = parts_element(value)
+        place_pub = compact_and_join_with_delimiter([place, publisher], ' : ')
+        edition_place = compact_and_join_with_delimiter([edition, place_pub], ' - ')
+        joined_place_parts = compact_and_join_with_delimiter([edition_place, parts], ', ')
+
+        unless joined_place_parts.empty?
+          return_fields << ModsDisplay::Values.new(
+            label: displayLabel(value) || I18n.t('mods_display.imprint'),
+            values: [joined_place_parts]
+          )
         end
+        return_fields.concat(date_values(value))
+
+        other_pub_info(value).each do |pub_info|
+          return_fields << ModsDisplay::Values.new(
+            label: displayLabel(value) || pub_info_labels[pub_info.name.to_sym],
+            values: [pub_info.text.strip]
+          )
+        end
+
+        return_fields.compact
       end
-      collapse_fields(return_fields)
     end
 
-    def dates(element)
+    def date_values(element)
       date_field_keys.map do |date_field|
         next unless element.respond_to?(date_field)
+
         elements = element.send(date_field)
         next if elements.empty?
+
         ModsDisplay::Values.new(
           label: displayLabel(element) || pub_info_labels[elements.first.name.to_sym],
           values: parse_dates(elements)
@@ -46,167 +53,147 @@ module ModsDisplay
       end.compact
     end
 
-    def parse_dates(date_field)
-      apply_date_qualifier_decoration(
-        dedup_dates(
-          join_date_ranges(
-            process_bc_ad_dates(
-              process_encoded_dates(ignore_bad_dates(date_field))
-            )
-          )
-        )
-      )
-    end
+    class DateValue
+        attr_reader :value
+        delegate :text, :date, :point, :qualifier, :encoding, to: :value
 
-    def ignore_bad_dates(date_fields)
-      date_fields.select do |date_field|
-        date_field.text.strip != '9999'
-      end
-    end
+        def initialize(value)
+          @value = value
+        end
 
-    def process_encoded_dates(date_fields)
-      date_fields.map do |date_field|
-        if date_is_w3cdtf?(date_field)
-          process_w3cdtf_date(date_field)
-        elsif date_is_iso8601?(date_field)
-          process_iso8601_date(date_field)
-        else
-          date_field
+        # True if the element text isn't blank or the placeholder "9999".
+        def valid?
+          text.present? && !['9999', '0000-00-00', 'uuuu'].include?(text.strip)
         end
-      end
-    end
 
-    def join_date_ranges(date_fields)
-      if dates_are_range?(date_fields)
-        start_date = date_fields.find { |d| d.attributes['point'] && d.attributes['point'].value == 'start' }
-        end_date = date_fields.find { |d| d.attributes['point'] && d.attributes['point'].value == 'end' }
-        date_fields.map do |date|
-          date = date.clone # clone the date object so we don't append the same one
-          if normalize_date(date.text) == normalize_date(start_date.text)
-            date.content = [start_date.text, end_date.text].join('-')
-            date
-          elsif normalize_date(date.text) != normalize_date(end_date.text)
-            date
+        # Element text reduced to digits and hyphen. Captures date ranges and
+        # negative (B.C.) 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
-        end.compact
-      elsif dates_are_open_range?(date_fields)
-        start_date = date_fields.find { |d| d.attributes['point'] && d.attributes['point'].value == 'start' }
-        date_fields.map do |date|
-          date = date.clone # clone the date object so we don't append the same one
-          date.content = "#{start_date.text}-" if date.text == start_date.text
-          date
-        end
-      else
-        date_fields
-      end
-    end
 
-    def apply_date_qualifier_decoration(date_fields)
-      return_fields = date_fields.map do |date|
-        date = date.clone
-        if date_is_approximate?(date)
-          date.content = "[ca. #{date.text}]"
-        elsif date_is_questionable?(date)
-          date.content = "[#{date.text}?]"
-        elsif date_is_inferred?(date)
-          date.content = "[#{date.text}]"
+          text.gsub(/(?<![\d])(\d{1,3})([xu-]{1,3})/i) { "#{$1}#{'0' * $2.length}"}.scan(/[\d-]/).join
         end
-        date
-      end
-      return_fields.map(&:text)
-    end
 
-    def date_is_approximate?(date_field)
-      date_field.attributes['qualifier'] &&
-        date_field.attributes['qualifier'].respond_to?(:value) &&
-        date_field.attributes['qualifier'].value == 'approximate'
-    end
+        # Decoded version of the date, if it was encoded. Strips leading zeroes.
+        def decoded_value
+          return text.strip unless date
 
-    def date_is_questionable?(date_field)
-      date_field.attributes['qualifier'] &&
-        date_field.attributes['qualifier'].respond_to?(:value) &&
-        date_field.attributes['qualifier'].value == 'questionable'
-    end
+          unless encoding.present?
+            return text.strip unless text =~ /^-?\d+$/ || text =~ /^[\dXxu?-]{4}$/
+          end
 
-    def date_is_inferred?(date_field)
-      date_field.attributes['qualifier'] &&
-        date_field.attributes['qualifier'].respond_to?(:value) &&
-        date_field.attributes['qualifier'].value == 'inferred'
-    end
+          # Delegate to the appropriate decoding method, if any
+          case value.precision
+          when :day
+            date.strftime('%B %e, %Y')
+          when :month
+            date.strftime('%B %Y')
+          when :year
+            year = date.year
+            if year < 1
+              "#{year.abs + 1} B.C."
+            # Any dates before the year 1000 are explicitly marked A.D.
+            elsif year > 1 && year < 1000
+              "#{year} A.D."
+            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
+          end
+        end
 
-    def dates_are_open_range?(date_fields)
-      date_fields.any? do |field|
-        field.attributes['point'] &&
-          field.attributes['point'].respond_to?(:value) &&
-          field.attributes['point'].value == 'start'
-      end && !date_fields.any? do |field|
-        field.attributes['point'] &&
-          field.attributes['point'].respond_to?(:value) &&
-          field.attributes['point'].value == 'end'
-      end
-    end
+        # Decoded date with "B.C." or "A.D." 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'
 
-    def dates_are_range?(date_fields)
-      attributes = date_fields.map do |date|
-        if date.attributes['point'].respond_to?(:value)
-          date.attributes['point'].value
+          date
         end
       end
-      attributes.include?('start') &&
-        attributes.include?('end')
-    end
 
-    def date_is_w3cdtf?(date_field)
-      field_is_encoded?(date_field, 'w3cdtf')
-    end
+      class DateRange
+        def initialize(start: nil, stop: nil)
+          @start = start
+          @stop = stop
+        end
 
-    def date_is_iso8601?(date_field)
-      field_is_encoded?(date_field, 'iso8601')
-    end
+        # Base value as hyphen-joined string. Used for comparison/deduping.
+        def base_value
+          "#{@start&.base_value}-#{@stop&.base_value}"
+        end
 
-    def process_w3cdtf_date(date_field)
-      date_field = date_field.clone
-      date_field.content = begin
-        if date_field.text.strip =~ /^\d{4}-\d{2}-\d{2}$/
-          Date.parse(date_field.text).strftime('%B %d, %Y')
-        elsif date_field.text.strip =~ /^\d{4}-\d{2}$/
-          Date.parse("#{date_field.text}-01").strftime('%B %Y')
-        else
-          date_field.content
+        # Base values as array. Used for comparison/deduping of individual dates.
+        def base_values
+          [@start&.base_value, @stop&.base_value].compact
         end
-      rescue
-        date_field.content
-      end
-      date_field
-    end
 
-    def process_iso8601_date(date_field)
-      date_field = date_field.clone
-      date_field.content = begin
-        Date.iso8601(date_field.text).strftime('%B %d, %Y')
-      rescue
-        date_field.content
+        # The encoding value for the start of the range, or stop if not present.
+        def encoding
+          @start&.encoding || @stop&.encoding
+        end
+
+        # Decoded dates with "B.C." or "A.D." 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}"
+            return "[ca. #{date}]" if qualifier == 'approximate'
+            return "[#{date}?]" if qualifier == 'questionable'
+            return "[#{date}]" if qualifier == 'inferred'
+
+            date
+          else
+            "#{@start&.qualified_value}-#{@stop&.qualified_value}"
+          end
+        end
       end
-      date_field
-    end
+    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)
+      end
+      dates = nonpoint
+
+      # ensure dates are unique with respect to their base values
+      dates = dates.group_by(&:base_value).map do |_value, group|
+        group.first if group.one?
 
-    def dedup_dates(date_fields)
-      date_text = date_fields.map { |d| normalize_date(d.text) }
-      if date_text != date_text.uniq
-        if date_fields.find { |d| d.attributes['qualifier'].respond_to?(:value) }
-          [date_fields.find { |d| d.attributes['qualifier'].respond_to?(:value) }]
-        elsif date_fields.find { |d| !d.attributes['encoding'] }
-          [date_fields.find { |d| !d.attributes['encoding'] }]
+        # if one of the duplicates wasn't encoded, use that one. see:
+        # https://consul.stanford.edu/display/chimera/MODS+display+rules#MODSdisplayrules-3b.%3CoriginInfo%3E
+        if group.reject(&:encoding).any?
+          group.reject(&:encoding).first
+
+        # otherwise just randomly pick the last in the group
         else
-          [date_fields.first]
+          group.last
         end
-      else
-        date_fields
       end
-    end
 
-    def normalize_date(date)
-      date.strip.gsub(/^\[*ca\.\s*|c|\[|\]|\?/, '')
+      # if any single dates are already part of a range, discard them
+      range_base_values = dates.select { |date| date.is_a?(DateRange) }
+                               .map(&:base_values).flatten
+      dates = dates.reject { |date| range_base_values.include?(date.base_value) }
+
+      # output formatted dates with qualifiers, A.D./B.C., etc.
+      dates.map(&:qualified_value)
     end
 
     def other_pub_info(element)
@@ -218,6 +205,7 @@ module ModsDisplay
     def place_terms(element)
       return [] unless element.respond_to?(:place) &&
                        element.place.respond_to?(:placeTerm)
+
       if unencoded_place_terms?(element)
         element.place.placeTerm.select do |term|
           !term.attributes['type'].respond_to?(:value) ||
@@ -230,6 +218,7 @@ module ModsDisplay
                       term.attributes['authority'].respond_to?(:value) &&
                       term.attributes['authority'].value == 'marccountry' &&
                       country_codes.include?(term.text.strip)
+
           term = term.clone
           term.content = country_codes[term.text.strip]
           term
@@ -244,63 +233,23 @@ module ModsDisplay
       end
     end
 
-    def imprint_display_form(element)
-      display_form = element.children.find do |child|
-        child.name == 'displayForm'
-      end
-      ModsDisplay::Values.new(
-        label: displayLabel(element) || I18n.t('mods_display.imprint'),
-        values: [display_form.text]
-      ) if display_form
-    end
-
     private
 
     def compact_and_join_with_delimiter(values, delimiter)
       compact_values = values.compact.reject { |v| v.strip.empty? }
       return compact_values.join(delimiter) if compact_values.length == 1 ||
                                                !ends_in_terminating_punctuation?(delimiter)
+
       compact_values.each_with_index.map do |value, i|
-        if (compact_values.length - 1) == i || # last item?
-           ends_in_terminating_punctuation?(value)
-          value << ' '
-        else
-          value << delimiter
-        end
+        value << if (compact_values.length - 1) == i || # last item?
+                    ends_in_terminating_punctuation?(value)
+                   ' '
+                 else
+                   delimiter
+                 end
       end.join.strip
     end
 
-    def process_bc_ad_dates(date_fields)
-      date_fields.map do |date_field|
-        case
-        when date_is_bc_edtf?(date_field)
-          year = date_field.text.strip.gsub(/^-0*/, '').to_i + 1
-          date_field.content = "#{year} B.C."
-        when date_is_ad?(date_field)
-          date_field.content = "#{date_field.text.strip.gsub(/^0*/, '')} A.D."
-        end
-        date_field
-      end
-    end
-
-    def date_is_bc_edtf?(date_field)
-      date_field.text.strip.start_with?('-') && date_is_edtf?(date_field)
-    end
-
-    def date_is_ad?(date_field)
-      date_field.text.strip.gsub(/^0*/, '').length < 4
-    end
-
-    def date_is_edtf?(date_field)
-      field_is_encoded?(date_field, 'edtf')
-    end
-
-    def field_is_encoded?(field, encoding)
-      field.attributes['encoding'] &&
-        field.attributes['encoding'].respond_to?(:value) &&
-        field.attributes['encoding'].value.downcase == encoding
-    end
-
     def ends_in_terminating_punctuation?(value)
       value.strip.end_with?('.', ',', ':', ';')
     end
@@ -313,6 +262,7 @@ module ModsDisplay
 
     def place_element(value)
       return if value.place.text.strip.empty?
+
       places = place_terms(value).reject do |p|
         p.text.strip.empty?
       end.map(&:text)
@@ -321,6 +271,7 @@ module ModsDisplay
 
     def publisher_element(value)
       return if value.publisher.text.strip.empty?
+
       publishers = value.publisher.reject do |p|
         p.text.strip.empty?
       end.map(&:text)
@@ -328,8 +279,9 @@ module ModsDisplay
     end
 
     def parts_element(value)
-      date_elements = %w(dateIssued dateOther).map do |date_field_name|
+      date_elements = %w[dateIssued dateOther].map do |date_field_name|
         next unless value.respond_to?(date_field_name.to_sym)
+
         parse_dates(value.send(date_field_name.to_sym))
       end.flatten.compact.reject do |date|
         date.strip.empty?
@@ -338,11 +290,11 @@ module ModsDisplay
     end
 
     def pub_info_parts
-      [:issuance, :frequency]
+      %i[issuance frequency]
     end
 
     def date_field_keys
-      [:dateCreated, :dateCaptured, :dateValid, :dateModified, :copyrightDate]
+      %i[dateCreated dateCaptured dateValid dateModified copyrightDate]
     end
 
     def pub_info_labels
@@ -352,8 +304,7 @@ module ModsDisplay
         dateModified: I18n.t('mods_display.date_modified'),
         copyrightDate: I18n.t('mods_display.copyright_date'),
         issuance: I18n.t('mods_display.issuance'),
-        frequency: I18n.t('mods_display.frequency')
-      }
+        frequency: I18n.t('mods_display.frequency') }
     end
   end
 end

data/lib/mods_display/fields/language.rb

@@ -1,13 +1,17 @@
+# frozen_string_literal: true
+
 module ModsDisplay
   class Language < Field
     def fields
       return_fields = @values.map do |value|
         next unless value.respond_to?(:languageTerm)
+
         value.languageTerm.map do |term|
           next unless term.attributes['type'].respond_to?(:value) && term.attributes['type'].value == 'code'
+
           ModsDisplay::Values.new(
             label: displayLabel(value) || displayLabel(term) || I18n.t('mods_display.language'),
-            values: [displayForm(value) || language_codes[term.text]].flatten
+            values: [language_codes[term.text]]
           )
         end.flatten.compact
       end.flatten.compact

data/lib/mods_display/fields/location.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ModsDisplay
   class Location < Field
     def fields
@@ -5,6 +7,7 @@ module ModsDisplay
       @values.each do |location|
         location.children.each do |child|
           next unless location_field_keys.include?(child.name.to_sym)
+
           if child.name.to_sym == :url
             loc_label = displayLabel(location) || I18n.t('mods_display.location')
             value = "<a href='#{child.text}'>#{(displayLabel(child) || child.text).gsub(/:$/, '')}</a>"
@@ -24,7 +27,7 @@ module ModsDisplay
     private
 
     def location_field_keys
-      [:physicalLocation, :url, :shelfLocator, :holdingSimple, :holdingExternal]
+      %i[physicalLocation url shelfLocator holdingSimple holdingExternal]
     end
 
     def location_label(element)

data/lib/mods_display/fields/name.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ModsDisplay
   class Name < Field
     include ModsDisplay::RelatorCodes
     def fields
       return_fields = @values.map do |value|
-        person = if value.displayForm.length > 0
+        person = if value.displayForm.length.positive?
                    ModsDisplay::Name::Person.new(name: value.displayForm.text)
                  elsif !name_parts(value).empty?
                    ModsDisplay::Name::Person.new(name: name_parts(value))
@@ -40,11 +42,25 @@ module ModsDisplay
     def role_labels(element)
       default_label = I18n.t('mods_display.associated_with')
       return [default_label] unless element.role.present? && element.role.roleTerm.present?
-      element.role.roleTerm.collect do |role|
-        relator_codes[role.text.downcase] || role.text.capitalize || default_label
+
+      element.role.collect do |role|
+        codes, text = role.roleTerm.partition { |term| term['type'] == 'code' }
+
+        # prefer mappable role term codes
+        label = codes.map { |term| relator_codes[term.text.downcase] }.first
+
+        # but fall back to given text
+        label ||= text.map { |term| format_role(term) }.first
+
+        # or just the default
+        label || default_label
       end.uniq
     end
 
+    def format_role(element)
+      element.text.capitalize.sub(/[.,:;]+$/, '')
+    end
+
     def role?(element)
       element.respond_to?(:role) && !element.role.empty?
     end
@@ -55,10 +71,9 @@ module ModsDisplay
     end
 
     def name_parts(element)
-      output = ''
-      output << [unqualified_name_parts(element),
-                 qualified_name_parts(element, 'family'),
-                 qualified_name_parts(element, 'given')].flatten.compact.join(', ')
+      output = [unqualified_name_parts(element),
+                qualified_name_parts(element, 'family'),
+                qualified_name_parts(element, 'given')].flatten.compact.join(', ')
       terms = qualified_name_parts(element, 'termsOfAddress')
       unless terms.empty?
         term_delimiter = ', '
@@ -66,9 +81,7 @@ module ModsDisplay
         output = [output, terms.join(', ')].flatten.compact.join(term_delimiter)
       end
       dates = qualified_name_parts(element, 'date')
-      unless dates.empty?
-        output = [output, qualified_name_parts(element, 'date')].flatten.compact.join(', ')
-      end
+      output = [output, qualified_name_parts(element, 'date')].flatten.compact.join(', ') unless dates.empty?
       output
     end
 
@@ -90,7 +103,7 @@ module ModsDisplay
     def name_part_begins_with_roman_numeral?(part)
       first_part = part.split(/\s|,/).first.strip
       first_part.chars.all? do |char|
-        %w(I X C L V).include? char
+        %w[I X C L V].include? char
       end
     end
 
@@ -98,14 +111,16 @@ module ModsDisplay
       roles = element.role.map do |role|
         role.roleTerm.find do |term|
           term.attributes['type'].respond_to?(:value) &&
-          term.attributes['type'].value == 'text'
+            term.attributes['type'].value == 'text'
         end
       end.compact
-      roles = element.role.map do |role|
-        role.roleTerm.find do |term|
-          !term.attributes['type'].respond_to?(:value)
-        end
-      end.compact if roles.empty?
+      if roles.empty?
+        roles = element.role.map do |role|
+          role.roleTerm.find do |term|
+            !term.attributes['type'].respond_to?(:value)
+          end
+        end.compact
+      end
       roles.map { |t| t.text.strip }
     end
 
@@ -130,7 +145,7 @@ module ModsDisplay
     # Normalize label headings by filtering out some punctuation and ending in :
     def normalize_labels(label_order, results)
       label_order.uniq.map do |k|
-        label = k.tr('.', '').tr(':', '').strip + ':'
+        label = "#{k.tr('.', '').tr(':', '').strip}:"
         if label != k
           results[label] = results[k]
           results.delete(k)
@@ -152,8 +167,9 @@ module ModsDisplay
 
     class Person
       attr_accessor :name
+
       def initialize(data)
-        @name =  data[:name]
+        @name = data[:name]
       end
 
       def to_s