mods_display 1.4.0 → 1.6.0

data/lib/mods_display/fields/identifier.rb

@@ -3,8 +3,11 @@
 module ModsDisplay
   class Identifier < Field
     def fields
-      return_fields = @values.map do |value|
-        ModsDisplay::Values.new(label: displayLabel(value) || identifier_label(value), values: [element_text(value)])
+      return_fields = @stanford_mods_elements.map do |identifier_element|
+        ModsDisplay::Values.new(
+          label: displayLabel(identifier_element) || identifier_label(identifier_element),
+          values: [element_text(identifier_element)]
+        )
       end
       collapse_fields(return_fields)
     end

data/lib/mods_display/fields/imprint.rb

@@ -9,28 +9,28 @@ module ModsDisplay
     end
 
     def origin_info_data
-      @values.map do |value|
+      @stanford_mods_elements.map do |origin_info_element|
         return_fields = []
 
-        edition = edition_element(value)
-        place = place_element(value)
-        publisher = publisher_element(value)
-        parts = parts_element(value)
+        edition = edition_element(origin_info_element)
+        place = place_element(origin_info_element)
+        publisher = publisher_element(origin_info_element)
+        parts = parts_element(origin_info_element)
         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'),
+            label: displayLabel(origin_info_element) || I18n.t('mods_display.imprint'),
             values: [joined_place_parts]
           )
         end
-        return_fields.concat(date_values(value))
+        return_fields.concat(date_values(origin_info_element))
 
-        other_pub_info(value).each do |pub_info|
+        other_pub_info(origin_info_element).each do |pub_info|
           return_fields << ModsDisplay::Values.new(
-            label: displayLabel(value) || pub_info_labels[pub_info.name.to_sym],
+            label: displayLabel(origin_info_element) || pub_info_labels[pub_info.name.to_sym],
             values: [element_text(pub_info)]
           )
         end
@@ -48,7 +48,7 @@ module ModsDisplay
 
         ModsDisplay::Values.new(
           label: displayLabel(element) || pub_info_labels[date_field],
-          values: select_the_best_date(date_values)
+          values: select_best_date(date_values)
         )
       end.compact
     end
@@ -117,6 +117,8 @@ module ModsDisplay
       end.map(&:text).join(' ').strip
     end
 
+    # not an exact duplicate of the method in ModsDisplay::Place, particularly trailing punctuation code
+    #  as ModsDisplay::Place is not intended to combine with publisher in an imprint string
     def place_element(value)
       return if value.place.text.strip.empty?
 
@@ -142,7 +144,7 @@ module ModsDisplay
         date_values = imprint.dates([date_field])
         next if date_values.empty?
 
-        select_the_best_date(date_values)
+        select_best_date(date_values)
       end.flatten.compact.reject do |date|
         date.strip.empty?
       end.map(&:strip)
@@ -162,30 +164,5 @@ module ModsDisplay
         issuance: I18n.t('mods_display.issuance'),
         frequency: I18n.t('mods_display.frequency') }
     end
-
-    def select_the_best_date(dates)
-      # 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?
-
-        # 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
-          group.last
-        end
-      end
-
-      # if any single dates are already part of a range, discard them
-      range_base_values = dates.select { |date| date.is_a?(Stanford::Mods::Imprint::DateRange) }
-                               .map(&:base_values).flatten
-      dates = dates.reject { |date| range_base_values.include?(date.base_value) }
-
-      # output formatted dates with qualifiers, CE/BCE, etc.
-      dates.map(&:qualified_value)
-    end
   end
 end

data/lib/mods_display/fields/issuance.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ModsDisplay
+  class Issuance < Field
+    def fields
+      return_fields = @stanford_mods_elements.map do |origin_info_element|
+        issuance_value = origin_info_element.issuance&.text&.strip
+        next unless issuance_value.present?
+
+        ModsDisplay::Values.new(
+          label: I18n.t('mods_display.issuance'),
+          values: [issuance_value],
+          field: self
+        )
+      end.compact
+      collapse_fields(return_fields)
+    end
+  end
+end

data/lib/mods_display/fields/language.rb

@@ -3,14 +3,14 @@
 module ModsDisplay
   class Language < Field
     def fields
-      return_fields = @values.map do |value|
-        next unless value.respond_to?(:languageTerm)
+      return_fields = @stanford_mods_elements.map do |language_element|
+        next unless language_element.respond_to?(:languageTerm)
 
-        value.languageTerm.map do |term|
+        language_element.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'),
+            label: displayLabel(language_element) || displayLabel(term) || I18n.t('mods_display.language'),
             values: [language_codes[element_text(term)]]
           )
         end.flatten.compact

data/lib/mods_display/fields/location.rb

@@ -4,20 +4,20 @@ module ModsDisplay
   class Location < Field
     def fields
       return_fields = []
-      @values.each do |location|
-        location.children.each do |child|
+      @stanford_mods_elements.each do |location_element|
+        location_element.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')
+            loc_label = displayLabel(location_element) || I18n.t('mods_display.location')
             value = "<a href='#{element_text(child)}'>#{(displayLabel(child) || element_text(child)).gsub(/:$/,
                                                                                                           '')}</a>"
           else
-            loc_label = location_label(child) || displayLabel(location) || I18n.t('mods_display.location')
+            loc_label = location_label(child) || displayLabel(location_element) || I18n.t('mods_display.location')
             value = element_text(child)
           end
           return_fields << ModsDisplay::Values.new(
-            label: loc_label || displayLabel(location) || I18n.t('mods_display.location'),
+            label: loc_label || displayLabel(location_element) || I18n.t('mods_display.location'),
             values: [value]
           )
         end

data/lib/mods_display/fields/name.rb

@@ -4,15 +4,16 @@ module ModsDisplay
   class Name < Field
     include ModsDisplay::RelatorCodes
 
-    # this returns a hash:
-    #  { role1 label => [ ModsDisplay:Name:Person,  ModsDisplay:Name:Person, ...], role2 label => [ ModsDisplay:Name:Person,  ModsDisplay:Name:Person, ...] }
+    # returns a hash:
+    #  { role1 label => [ ModsDisplay:Name:Person,  ModsDisplay:Name:Person, ...],
+    #    role2 label => [ ModsDisplay:Name:Person,  ModsDisplay:Name:Person, ...] }
     def fields
-      return_fields = @values.map do |value|
-        name_parts = ModsDisplay::NameFormatter.format(value)
-        person = name_parts ? ModsDisplay::Name::Person.new(name: name_parts, name_identifiers: value.xpath('mods:nameIdentifier', mods: MODS_NS)) : nil
+      return_fields = @stanford_mods_elements.map do |plain_name_element|
+        name_parts = ModsDisplay::NameFormatter.format(plain_name_element)
+        person = name_parts ? ModsDisplay::Name::Person.new(name: name_parts, name_identifiers: plain_name_element.xpath('mods:nameIdentifier', mods: MODS_NS)) : nil
         # The person may have multiple roles, so we have to divide them up into an array
-        role_labels(value).collect do |role_label|
-          ModsDisplay::Values.new(label: displayLabel(value) || role_label, values: [person]) if person
+        role_labels(plain_name_element).collect do |role_label|
+          ModsDisplay::Values.new(label: displayLabel(plain_name_element) || role_label, values: [person]) if person
         end
       end.flatten.compact
       collapse_roles(collapse_fields(return_fields))

data/lib/mods_display/fields/nested_related_item.rb

@@ -8,62 +8,70 @@ module ModsDisplay
   class NestedRelatedItem < Field
     include ModsDisplay::RelatedItemConcerns
 
+    def initialize(values, value_renderer: ValueRenderer)
+      super(values)
+      @value_renderer = value_renderer
+    end
+
     def fields
       @fields ||= begin
-        return_fields = RelatedItemValue.for_values(@values).map do |value|
-          next if value.collection?
-          next unless render_nested_related_item?(value)
+        return_fields = RelatedItemValue.for_values(@stanford_mods_elements).map do |related_item_element|
+          next if related_item_element.collection?
+          next unless render_nested_related_item?(related_item_element)
 
-          related_item_mods_object(value)
+          related_item_text = @value_renderer.new(related_item_element).render
+
+          ModsDisplay::Values.new(
+            label: related_item_label(related_item_element),
+            values: [related_item_text]
+          )
         end.compact
         collapse_fields(return_fields)
       end
     end
 
-    def to_html(view_context = ApplicationController.renderer)
-      helpers = view_context.respond_to?(:simple_format) ? view_context : ApplicationController.new.view_context
+    # this class provides html markup and is subclassed in purl application
+    class ValueRenderer
+      def initialize(related_item_element)
+        @related_item_element = related_item_element
+      end
 
-      component = ModsDisplay::ListFieldComponent.with_collection(
-        fields,
-        value_transformer: ->(value) { helpers.format_mods_html(value.to_s) },
-        list_html_attributes: { class: 'mods_display_nested_related_items' },
-        list_item_html_attributes: { class: 'mods_display_nested_related_item open' }
-      )
+      def render
+        [Array.wrap(mods_display_html.title).first, body_presence(mods_display_html.body)].compact.join
+      end
 
-      view_context.render component, layout: false
-    end
+      protected
 
-    private
+      attr_reader :related_item_element
 
-    def related_item_mods_object(value)
-      mods = ::Stanford::Mods::Record.new.tap do |r|
-        # dup'ing the value adds the appropriate namespaces, but...
-        munged_node = value.dup.tap do |x|
-          # ... the mods gem also expects the root of the document to have the root tag <mods>
-          x.name = 'mods'
-        end
-
-        r.from_nk_node(munged_node)
+      def mods_display_html
+        @mods_display_html ||= ModsDisplay::HTML.new(mods)
       end
-      related_item = ModsDisplay::HTML.new(mods)
 
-      ModsDisplay::Values.new(
-        label: related_item_label(value),
-        values: [[Array.wrap(related_item.title).first, related_item_body(related_item)].compact.join]
-      )
-    end
+      def mods
+        @mods ||= ::Stanford::Mods::Record.new.tap do |r|
+          # dup'ing the value adds the appropriate namespaces, but...
+          munged_node = related_item_element.dup.tap do |x|
+            # ... the mods gem also expects the root of the document to have the root tag <mods>
+            x.name = 'mods'
+          end
 
-    def related_item_body(related_item)
-      body = related_item.body
+          r.from_nk_node(munged_node)
+        end
+      end
 
-      return if body == '<dl></dl>'
+      def body_presence(body)
+        return if body == '<dl></dl>'
 
-      body
+        body
+      end
     end
 
-    def related_item_label(item)
-      return displayLabel(item) if displayLabel(item)
-      return I18n.t('mods_display.constituent') if item.constituent?
+    private
+
+    def related_item_label(related_item_element)
+      return displayLabel(related_item_element) if displayLabel(related_item_element)
+      return I18n.t('mods_display.constituent') if related_item_element.constituent?
 
       I18n.t('mods_display.host')
     end

data/lib/mods_display/fields/note.rb

@@ -3,9 +3,12 @@
 module ModsDisplay
   class Note < Field
     def fields
-      return_fields = note_fields.map do |value|
-        ModsDisplay::Values.new(label: displayLabel(value) || note_label(value), values: [element_text(value)],
-                                field: self)
+      return_fields = note_fields.map do |note_element|
+        ModsDisplay::Values.new(
+          label: displayLabel(note_element) || note_label(note_element),
+          values: [element_text(note_element)],
+          field: self
+        )
       end
       collapse_fields(return_fields)
     end
@@ -17,10 +20,10 @@ module ModsDisplay
     end
 
     def note_fields
-      @values.select do |value|
-        (!value.attributes['type'].respond_to?(:value) ||
-           (value.attributes['type'].respond_to?(:value) &&
-              value.attributes['type'].value.downcase != 'contact'))
+      @stanford_mods_elements.select do |note_element|
+        !note_element.attributes['type'].respond_to?(:value) ||
+          (note_element.attributes['type'].respond_to?(:value) &&
+             note_element.attributes['type'].value.downcase != 'contact')
       end
     end
 

data/lib/mods_display/fields/place.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ModsDisplay
+  class Place < Field
+    include ModsDisplay::CountryCodes
+
+    def fields
+      return_fields = @stanford_mods_elements.map do |origin_info_element|
+        place_value = place_element(origin_info_element)
+        next unless place_value.present?
+
+        ModsDisplay::Values.new(
+          label: I18n.t('mods_display.place'),
+          values: [place_value],
+          field: self
+        )
+      end.compact
+      collapse_fields(return_fields)
+    end
+
+    private
+
+    # not an exact duplicate of the method in Imprint, particularly trailing punctuation code
+    def place_element(origin_info_element)
+      return if origin_info_element.place.text.strip.empty?
+
+      places = ModsDisplay::Imprint.new(origin_info_element).place_terms(origin_info_element).filter_map { |p| p.text unless p.text.strip.empty? }
+      compact_and_remove_trailing_delimiter(places, ':').join
+    end
+
+    def compact_and_remove_trailing_delimiter(values, delimiter = ':')
+      values.flatten.filter_map { |v| v.gsub(/ *#{delimiter}$/, '') if v.present? }.compact
+    end
+  end
+end

data/lib/mods_display/fields/publisher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ModsDisplay
+  class Publisher < Field
+    def fields
+      return_fields = @stanford_mods_elements.map do |origin_info_element|
+        publisher_value = Stanford::Mods::Imprint.new(origin_info_element).publisher_vals_str
+        next unless publisher_value.present?
+
+        publisher_value.gsub!(/ *,$/, '')
+
+        ModsDisplay::Values.new(
+          label: I18n.t('mods_display.publisher'),
+          values: [publisher_value],
+          field: self
+        )
+      end.compact
+      collapse_fields(return_fields)
+    end
+  end
+end

data/lib/mods_display/fields/reference_title.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ModsDisplay
+  class ReferenceTitle < Field
+    def fields
+      # Reference title is a composite field that includes parts from elsewhere in the record.
+      return [] unless @stanford_mods_elements.present?
+
+      return_fields = [ModsDisplay::Values.new(label: displayLabel(@stanford_mods_elements.first) || label, values: [title_value].compact)]
+      collapse_fields(return_fields)
+    end
+
+    private
+
+    def root
+      @root ||= @stanford_mods_elements.first.document.root
+    end
+
+    def displayLabel(element)
+      super(element) || I18n.t('mods_display.referenced_by')
+    end
+
+    def title_value
+      [@stanford_mods_elements,
+       root.xpath('mods:originInfo/mods:dateOther', mods: MODS_NS),
+       root.xpath('mods:part/mods:detail/mods:number', mods: MODS_NS),
+       root.xpath('mods:note', mods: MODS_NS)].flatten.compact.map!(&:text).map!(&:strip).join(' ').presence
+    end
+  end
+end

data/lib/mods_display/fields/related_item.rb

@@ -4,65 +4,84 @@ module ModsDisplay
   class RelatedItem < Field
     include ModsDisplay::RelatedItemConcerns
 
-    def fields
-      return_fields = RelatedItemValue.for_values(@values).map do |value|
-        next if value.collection?
-        next if render_nested_related_item?(value)
+    def initialize(values, value_renderer: ValueRenderer)
+      super(values)
+      @value_renderer = value_renderer
+    end
 
-        text = related_item_value(value)
+    def fields
+      return_fields = RelatedItemValue.for_values(@stanford_mods_elements).map do |related_item_element|
+        next if related_item_element.collection?
+        next if render_nested_related_item?(related_item_element)
 
+        text = @value_renderer.new(related_item_element).render
         next if text.nil? || text.empty?
 
-        ModsDisplay::Values.new(label: related_item_label(value), values: [text])
+        ModsDisplay::Values.new(
+          label: related_item_label(related_item_element),
+          values: [text]
+        )
       end.compact
       collapse_fields(return_fields)
     end
 
-    private
+    # this class provides html markup and is mimicking the same class
+    #   in NestedRelatedItem (which is subclassed in purl application)
+    class ValueRenderer
+      def initialize(related_item_element)
+        @related_item_element = related_item_element
+      end
 
-    def delimiter
-      '<br />'.html_safe
-    end
+      def render
+        if related_item_element.location?
+          element_text(related_item_element.location_nodeset)
+        elsif related_item_element.reference?
+          reference_title(related_item_element)
+        elsif related_item_element.titleInfo_nodeset.any?
+          title = element_text(related_item_element.titleInfo_nodeset)
+          location = nil
+          location = element_text(related_item_element.location_url_nodeset) if related_item_element.location_url_nodeset.length.positive?
+
+          return if title.empty?
+
+          if location
+            "<a href='#{location}'>#{title}</a>".html_safe
+          else
+            title
+          end
+        elsif related_item_element.note_nodeset.any?
+          citation = related_item_element.note_nodeset.find { |note| note['type'] == 'preferred citation' }
 
-    def related_item_value(item)
-      if item.location?
-        element_text(item.location_nodeset)
-      elsif item.reference?
-        reference_title(item)
-      elsif item.titleInfo_nodeset.any?
-        title = element_text(item.titleInfo_nodeset)
-        location = nil
-        location = element_text(item.location_url_nodeset) if item.location_url_nodeset.length.positive?
-
-        return if title.empty?
-
-        if location
-          "<a href='#{location}'>#{title}</a>".html_safe
-        else
-          title
+          element_text(citation) if citation
         end
-      elsif item.note_nodeset.any?
-        citation = item.note_nodeset.find { |note| note['type'] == 'preferred citation' }
+      end
+
+      protected
 
-        element_text(citation) if citation
+      attr_reader :related_item_element
+
+      def element_text(element)
+        element.xpath('.//text()').to_html.strip
       end
-    end
 
-    def reference_title(item)
-      [item.titleInfo_nodeset,
-       item.originInfo.dateOther,
-       item.part.detail.number,
-       item.note_nodeset].flatten.compact.map!(&:text).map!(&:strip).join(' ')
+      def reference_title(related_item_element)
+        [related_item_element.titleInfo_nodeset,
+         related_item_element.originInfo.dateOther,
+         related_item_element.part.detail.number,
+         related_item_element.note_nodeset].flatten.compact.map!(&:text).map!(&:strip).join(' ')
+      end
     end
 
-    def related_item_label(item)
-      if displayLabel(item)
-        displayLabel(item)
+    private
+
+    def related_item_label(related_item_element)
+      if displayLabel(related_item_element)
+        displayLabel(related_item_element)
       else
         case
-        when item.location?
+        when related_item_element.location?
           return I18n.t('mods_display.location')
-        when item.reference?
+        when related_item_element.reference?
           return I18n.t('mods_display.referenced_by')
         end
         I18n.t('mods_display.related_item')

data/lib/mods_display/fields/resource_type.rb

@@ -3,16 +3,19 @@
 module ModsDisplay
   class ResourceType < Field
     def fields
-      return_fields = @values.map do |value|
-        ModsDisplay::Values.new(label: displayLabel(value) || label, values: [element_text(value)])
+      return_fields = @stanford_mods_elements.map do |type_of_resource_element|
+        ModsDisplay::Values.new(
+          label: displayLabel(type_of_resource_element) || label,
+          values: [element_text(type_of_resource_element)]
+        )
       end
       collapse_fields(return_fields)
     end
 
     private
 
-    def displayLabel(element)
-      super(element) || I18n.t('mods_display.type_of_resource')
+    def displayLabel(type_of_resource_element)
+      super(type_of_resource_element) || I18n.t('mods_display.type_of_resource')
     end
   end
 end

data/lib/mods_display/fields/subject.rb

@@ -4,11 +4,11 @@ module ModsDisplay
   class Subject < Field
     def fields
       return_fields = []
-      @values.each do |value|
+      @stanford_mods_elements.each do |subject_element|
         return_values = []
-        label = displayLabel(value) || I18n.t('mods_display.subject')
+        label = displayLabel(subject_element) || I18n.t('mods_display.subject')
         return_text = []
-        selected_subjects(value).each do |child|
+        selected_subjects(subject_element).each do |child|
           if respond_to?(:"process_#{child.name}")
             method_send = send(:"process_#{child.name}", child)
             return_text << method_send unless method_send.to_s.empty?