mods_display 0.10.0 → 1.0.0.alpha3

data/app/components/mods_display/field_component.rb

@@ -0,0 +1,27 @@
+module ModsDisplay
+  class FieldComponent < ViewComponent::Base
+    with_collection_parameter :field
+
+    def initialize(field:, delimiter: nil, label_html_attributes: {}, value_html_attributes: {}, value_transformer: nil)
+      super
+
+      @field = field
+      @delimiter = delimiter
+      @value_transformer = value_transformer
+      @label_html_attributes = label_html_attributes
+      @value_html_attributes = value_html_attributes
+    end
+
+    def render?
+      @field.values.any?(&:present?)
+    end
+
+    def format_value(value)
+      if @value_transformer
+        @value_transformer.call(value)
+      else
+        helpers.link_urls_and_email(value)
+      end
+    end
+  end
+end

data/app/components/mods_display/list_field_component.html.erb

@@ -0,0 +1,11 @@
+<% if @field.label %>
+  <%= tag.dt @field.label.sub(/:$/, ''), **@label_html_attributes %>
+<% end %>
+
+<%= tag.dd **@value_html_attributes do %>
+  <%= tag.ul **@list_html_attributes do %>
+    <% @field.values.select(&:present?).each do |value| %>
+      <%= tag.li format_value(value), **@list_item_html_attributes %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/components/mods_display/list_field_component.rb

@@ -0,0 +1,10 @@
+module ModsDisplay
+  class ListFieldComponent < ModsDisplay::FieldComponent
+    def initialize(field:, list_html_attributes: {}, list_item_html_attributes: {}, **args)
+      super(field: field, **args)
+
+      @list_html_attributes = list_html_attributes
+      @list_item_html_attributes = list_item_html_attributes
+    end
+  end
+end

data/app/components/mods_display/record_component.html.erb

@@ -0,0 +1,5 @@
+<%= tag.dl **@html_attributes do %>
+  <% @fields.each do |field| %>
+    <%= render @record.mods_field(field) %>
+  <% end %>
+<% end %>

data/app/components/mods_display/record_component.rb

@@ -0,0 +1,39 @@
+module ModsDisplay
+  class RecordComponent < ViewComponent::Base
+    DEFAULT_FIELDS = [
+      :subTitle,
+      :name,
+      :language,
+      :imprint,
+      :resourceType,
+      :genre,
+      :form,
+      :extent,
+      :geo,
+      :description,
+      :cartographics,
+      :abstract,
+      :contents,
+      :audience,
+      :note,
+      :contact,
+      :collection,
+      :nestedRelatedItem,
+      :relatedItem,
+      :subject,
+      :identifier,
+      :location
+      # :accessCondition
+    ].freeze
+
+    with_collection_parameter :record
+
+    def initialize(record:, fields: DEFAULT_FIELDS, html_attributes: {})
+      super
+
+      @record = record
+      @fields = fields
+      @html_attributes = html_attributes
+    end
+  end
+end

data/app/helpers/mods_display/record_helper.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ModsDisplay
+  module RecordHelper
+    def mods_display_label(label)
+      content_tag(:dt, label.delete(':')) + "\n".html_safe
+    end
+
+    # @private
+    def mods_display_content(values, delimiter = nil)
+      mods_record_field ModsDisplay::Values.new(values: Array(values)), delimiter
+    end
+
+    def mods_record_field(field, delimiter = nil, component: ModsDisplay::FieldComponent, &block)
+      render component.new(field: field, delimiter: delimiter, value_transformer: block)
+    end
+
+    def mods_name_field(field, &block)
+      mods_record_field(field) do |name|
+        block_given? ? capture { yield(name.name) } : name.name
+      end
+    end
+
+    def mods_display_name(values, &block)
+      mods_name_field(ModsDisplay::Values.new(values: Array(values)), &block)
+    end
+
+    # We need this to remove the ending ":" from the role labels only in data from
+    # mods_display
+    # @private (but currently used in searchworks)
+    def sanitize_mods_name_label(label)
+      label.sub(/:$/, '')
+    end
+
+    def mods_subject_field(field, &block)
+      mods_record_field(field) do |subject_line|
+        safe_join(link_mods_subjects(subject_line, &block), ' > ')
+      end
+    end
+
+    def mods_genre_field(field, &block)
+      mods_record_field(field) do |genre_line|
+        link_to_mods_subject(genre_line, &block)
+      end
+    end
+
+    # @private
+    def link_mods_genres(genre, &block)
+      link_buffer = []
+      link_to_mods_subject(genre, link_buffer, &block)
+    end
+
+    # @private
+    def link_mods_subjects(subjects, &block)
+      link_buffer = []
+      linked_subjects = []
+      subjects.each do |subject|
+        if subject.present?
+          linked_subjects << link_to_mods_subject(subject, link_buffer, &block)
+        end
+      end
+      linked_subjects
+    end
+
+    # @private
+    def link_to_mods_subject(subject, buffer = [], &block)
+      subject_text = subject.respond_to?(:name) ? subject.name : subject
+      link = block_given? ? capture { yield(subject_text, buffer) } : subject_text
+      buffer << subject_text.strip
+      link << " (#{subject.roles.join(', ')})" if subject.respond_to?(:roles) && subject.roles.present?
+      link
+    end
+
+    # rubocop:disable Layout/LineLength
+    # @private, but used in PURL currently
+    def link_urls_and_email(val, tags: %w[a dl dd dt i b em strong])
+      val = val.gsub(%r{<[^/> ]+}) do |possible_tag|
+        # Allow potentially valid HTML tags through to the sanitizer step, and HTML escape the rest
+        if tags.include? possible_tag[1..]
+          possible_tag
+        else
+          "&lt;#{possible_tag[1..]}"
+        end
+      end
+
+      # http://daringfireball.net/2010/07/improved_regex_for_matching_urls
+      url = %r{(?i)\b(?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\([^\s()<>]+|\([^\s()<>]+\)*\))+(?:\([^\s()<>]+|\([^\s()<>]+\)*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’])}i
+      # http://www.regular-expressions.info/email.html
+      email = %r{[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:[A-Z]{2}|com|org|net|edu|gov|mil|biz|info|mobi|name|aero|asia|jobs|museum)\b}i
+      matches = [val.scan(url), val.scan(email)].flatten.uniq
+      unless val =~ /<a/ # we'll assume that linking has alraedy occured and we don't want to double link
+        matches.each do |match|
+          if match =~ email
+            val.gsub!(match, "<a href='mailto:#{match}'>#{match}</a>")
+          else
+            val.gsub!(match, "<a href='#{match}'>#{match}</a>")
+          end
+        end
+      end
+
+      sanitize val, tags: tags, attributes: %w[href]
+    end
+    # rubocop:enable Layout/LineLength
+
+  end
+end

data/app/models/mods_display/record.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'stanford-mods'
+
+##
+# A convenience object for parsing and rendering MODS
+module ModsDisplay
+  class Record
+    attr_reader :xml
+
+    def initialize(xml)
+      @xml = xml
+    end
+
+    def mods_record
+      return if xml.nil?
+      @mods_record ||= Stanford::Mods::Record.new.tap { |mods| mods.from_str(xml, false) }
+    end
+
+    def mods_display_html
+      return unless mods_record
+
+      ModsDisplay::HTML.new(mods_record)
+    end
+  end
+end

data/config/locales/en.yml

@@ -42,7 +42,7 @@ en:
     license: "License:"
     location: "Location:"
     map_data: "Map data:"
-    matrix_number: "Matric number:"
+    matrix_number: "Matrix number:"
     music_plate: "Music plate:"
     music_publisher: "Music publisher:"
     note: "Note:"

data/config.ru

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler"
+
+Bundler.require :default, :development
+
+Combustion.initialize! :all
+run Combustion::Application

data/lib/mods_display/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'view_component'
+
+module ModsDisplay
+  class Engine < ::Rails::Engine
+    initializer 'mods_display.helpers' do
+      config.after_initialize do
+        ActionView::Base.include ModsDisplay::RecordHelper
+      end
+    end
+  end
+end

data/lib/mods_display/fields/access_condition.rb

@@ -60,6 +60,10 @@ module ModsDisplay
 
     private
 
+    def delimiter
+      '<br />'
+    end
+
     def process_access_statement(element)
       case normalize_type(element)
       when 'copyright'

data/lib/mods_display/fields/contents.rb

@@ -1,21 +1,20 @@
 module ModsDisplay
   class Contents < Field
-    def to_html
-      return nil if fields.empty? || @config.ignore?
-      output = ''
-      fields.each do |field|
-        next unless field.values.any? { |f| f && !f.empty? }
-        output << "<dt#{label_class} #{sanitized_field_title(field.label)}>#{field.label}</dt>"
-        output << "<dd#{value_class}>"
-        output << '<ul><li>'
-        # compress all values into a "--"-delimited string then split them up
-        output << field.values.join('--').split('--').map(&:strip).map do |val|
-          @config.link ? link_to_value(val.to_s) : link_urls_and_email(val.to_s)
-        end.join('</li><li>')
-        output << '</li></ul>'
-        output << '</dd>'
+    def to_html(view_context = ApplicationController.renderer)
+      f = fields.map do |field|
+        ModsDisplay::Values.new(label: field.label, values: [field.values.join("\n\n")])
       end
-      output
+
+      helpers = view_context.respond_to?(:simple_format) ? view_context : ApplicationController.new.view_context
+
+      value_transformer = lambda do |value|
+        text = ERB::Util.h(value.gsub('&#10;', "\n"))
+        helpers.simple_format(text, {}, sanitize: false)
+      end
+
+      component = ModsDisplay::FieldComponent.with_collection(f, value_transformer: value_transformer)
+
+      view_context.render component, layout: false
     end
 
     private

data/lib/mods_display/fields/field.rb

@@ -1,10 +1,8 @@
 # encoding: utf-8
 module ModsDisplay
   class Field
-    def initialize(values, config, klass)
+    def initialize(values)
       @values = values
-      @config = config
-      @klass = klass
     end
 
     def fields
@@ -22,83 +20,18 @@ module ModsDisplay
       displayLabel(@values.first)
     end
 
-    def to_html
-      return nil if fields.empty? || @config.ignore?
-      output = ''
-      fields.each do |field|
-        next unless field.values.any? { |f| f && !f.empty? }
-        output << "<dt#{label_class} #{sanitized_field_title(field.label)}>#{field.label}</dt>"
-        output << "<dd#{value_class}>"
-        output << field.values.map do |val|
-          @config.link ? link_to_value(val.to_s) : link_urls_and_email(val.to_s)
-        end.join(@config.delimiter)
-        output << '</dd>'
-      end
-      output
+    def to_html(view_context = ApplicationController.renderer)
+      view_context.render ModsDisplay::FieldComponent.with_collection(fields, delimiter: delimiter), layout: false
     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
-      end.join.strip
+    def render_in(view_context)
+      to_html(view_context)
     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
-
-    def label_class
-      " class='#{@config.label_class}'" unless @config.label_class == ''
-    end
-
-    def value_class
-      " class='#{@config.value_class}'" unless @config.value_class == ''
-    end
+    private
 
-    def link_to_value(link_text, link_href = nil)
-      href_or_text = link_href || link_text
-      "<a href='#{@klass.send(@config.link[0], replace_tokens(@config.link[1], href_or_text))}'>#{link_text}</a>"
+    def delimiter
+      nil
     end
 
     def displayForm(element)
@@ -113,83 +46,14 @@ module ModsDisplay
       "#{element.attributes['displayLabel'].value}:"
     end
 
-    def sanitized_field_title(label)
-      "title='#{label.gsub(/:$/, '').strip}'"
-    end
-
-    def replace_tokens(object, value)
-      object = object.dup
-      if object.is_a?(Hash)
-        object.each do |k, v|
-          object[k] = replace_token(v, value)
-        end
-      elsif object.is_a?(String)
-        object = replace_token(object, value)
-      end
-      object
-    end
-
-    def replace_token(string, value)
-      string = string.dup
-      tokens.each do |token|
-        string.gsub!(token, value)
-      end
-      string
-    end
-
-    def tokens
-      ['%value%']
-    end
+    def collapse_fields(display_fields)
+      return display_fields if display_fields.length == 1
 
-    # rubocop:disable Metrics/LineLength
-    # Disabling line length due to necessarily long regular expressions
-    def link_urls_and_email(val)
-      val = val.dup
-      # http://daringfireball.net/2010/07/improved_regex_for_matching_urls
-      url = %r{(?i)\b(?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\([^\s()<>]+|\([^\s()<>]+\)*\))+(?:\([^\s()<>]+|\([^\s()<>]+\)*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’])}i
-      # http://www.regular-expressions.info/email.html
-      email = /[A-Z0-9_\.%\+\-\']+@(?:[A-Z0-9\-]+\.)+(?:[A-Z]{2,4}|museum|travel)/i
-      matches = [val.scan(url), val.scan(email)].flatten
-      unless val =~ /<a/ # we'll assume that linking has alraedy occured and we don't want to double link
-        matches.each do |match|
-          if match =~ email
-            val = val.gsub(match, "<a href='mailto:#{match}'>#{match}</a>")
-          else
-            val = val.gsub(match, "<a href='#{match}'>#{match}</a>")
-          end
-        end
-      end
-      val
-    end
-    # rubocop:enable Metrics/LineLength
+      display_fields.slice_when { |before, after| before.label != after.label }.map do |group|
+        next group.first if group.length == 1
 
-    def collapse_fields(display_fields)
-      return_values = []
-      current_label = nil
-      prev_label = nil
-      buffer = []
-      display_fields.each_with_index do |field, index|
-        current_label = field.label
-        current_values = field.values
-        if display_fields.length == 1
-          return_values << ModsDisplay::Values.new(label: current_label, values: current_values)
-        elsif index == (display_fields.length - 1)
-          # need to deal w/ when we have a last element but we have separate labels in the buffer.
-          if current_label != prev_label
-            return_values << ModsDisplay::Values.new(label: prev_label, values: buffer.flatten)
-            return_values << ModsDisplay::Values.new(label: current_label, values: current_values)
-          else
-            buffer.concat(current_values)
-            return_values << ModsDisplay::Values.new(label: current_label, values: buffer.flatten)
-          end
-        elsif prev_label && (current_label != prev_label)
-          return_values << ModsDisplay::Values.new(label: prev_label, values: buffer.flatten)
-          buffer = []
-        end
-        buffer.concat(current_values)
-        prev_label = current_label
+        ModsDisplay::Values.new(label: group.first.label, values: group.map(&:values).flatten)
       end
-      return_values
     end
   end
 end

data/lib/mods_display/fields/genre.rb

@@ -9,6 +9,10 @@ module ModsDisplay
 
     private
 
+    def delimiter
+      '<br />'
+    end
+
     def displayLabel(element)
       super(element) || I18n.t('mods_display.genre')
     end

data/lib/mods_display/fields/imprint.rb

@@ -168,9 +168,9 @@ module ModsDisplay
       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(@config.full_date_format)
+          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(@config.short_date_format)
+          Date.parse("#{date_field.text}-01").strftime('%B %Y')
         else
           date_field.content
         end
@@ -183,7 +183,7 @@ module ModsDisplay
     def process_iso8601_date(date_field)
       date_field = date_field.clone
       date_field.content = begin
-        Date.iso8601(date_field.text).strftime(@config.full_date_format)
+        Date.iso8601(date_field.text).strftime('%B %d, %Y')
       rescue
         date_field.content
       end
@@ -256,6 +256,55 @@ module ModsDisplay
 
     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
+      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
+
     def edition_element(value)
       value.edition.reject do |e|
         e.text.strip.empty?

data/lib/mods_display/fields/name.rb

@@ -16,26 +16,18 @@ module ModsDisplay
       collapse_roles(collapse_fields(return_fields))
     end
 
-    def to_html
-      return nil if fields.empty? || @config.ignore?
-      output = ''
-      fields.each do |field|
-        output << "<dt#{label_class} #{sanitized_field_title(field.label)}>#{field.label}</dt>"
-        output << "<dd#{value_class}>"
-        output << field.values.map do |val|
-          if @config.link
-            link_to_value(val.name)
-          else
-            val.to_s
-          end
-        end.join(@config.delimiter)
-        output << '</dd>'
-      end
-      output
+    def to_html(view_context = ApplicationController.renderer)
+      component = ModsDisplay::FieldComponent.with_collection(fields, value_transformer: ->(value) { value.to_s })
+
+      view_context.render component, layout: false
     end
 
     private
 
+    def delimiter
+      '<br />'
+    end
+
     def collapse_roles(fields)
       return [] if fields.blank?
 
@@ -150,12 +142,11 @@ module ModsDisplay
     def rebuild_fields_with_new_labels(label_keys, results)
       # Build the new fields data, stripping out the roles within the Person classes
       label_keys.uniq.map do |k|
-        mdv = ModsDisplay::Values.new({})
-        mdv.label = k
-        mdv.values = results[k].map do |person|
+        values = results[k].map do |person|
           ModsDisplay::Name::Person.new(name: person.name)
         end
-        mdv
+
+        ModsDisplay::Values.new(label: k, values: values)
       end
     end