mods_display 0.3.3 → 0.3.4

data/lib/mods_display/fields/abstract.rb

@@ -1,8 +1,9 @@
-class ModsDisplay::Abstract < ModsDisplay::Field
+module ModsDisplay
+  class Abstract < Field
+    private
 
-  private
-  def displayLabel(element)
-    super(element) || I18n.t('mods_display.abstract')
+    def displayLabel(element)
+      super(element) || I18n.t('mods_display.abstract')
+    end
   end
-
-end
+end

data/lib/mods_display/fields/access_condition.rb

@@ -1,73 +1,73 @@
-class ModsDisplay::AccessCondition < ModsDisplay::Field
-
-  def fields
-    return_fields = @values.map do |value|
-      ModsDisplay::Values.new(:label => displayLabel(value) || access_label(value), :values => [process_access_statement(value)])
+module ModsDisplay
+  class AccessCondition < Field
+    def fields
+      return_fields = @values.map do |value|
+        ModsDisplay::Values.new(
+          label: displayLabel(value) || access_label(value),
+          values: [process_access_statement(value)]
+        )
+      end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
-  end
 
-  private
+    private
 
-  def process_access_statement(element)
-    case normalize_type(element)
-    when "copyright"
-      copyright_statement(element)
-    when "license"
-      license_statement(element)
-    else
-      element.text
+    def process_access_statement(element)
+      case normalize_type(element)
+      when 'copyright'
+        copyright_statement(element)
+      when 'license'
+        license_statement(element)
+      else
+        element.text
+      end
     end
-  end
 
-  def copyright_statement(element)
-    element.text.gsub(/\(c\) copyright/i, "&copy;").gsub(/\(c\)/i, "&copy;")
-  end
+    def copyright_statement(element)
+      element.text.gsub(/\(c\) copyright/i, '&copy;').gsub(/\(c\)/i, '&copy;')
+    end
 
-  def license_statement(element)
-    element.text[/^(.*) (.*):(.*)$/]
-    output = "<div class='#{[$1,$2].join('-').downcase}'>"
-      if license_link($1, $2)
-        output << "<a href='#{license_link($1, $2)}'>#{$3.strip}</a>"
+    def license_statement(element)
+      element.text[/^(.*) (.*):(.*)$/]
+      output = "<div class='#{[Regexp.last_match(1), Regexp.last_match(2)].join('-').downcase}'>"
+      if license_link(Regexp.last_match(1), Regexp.last_match(2))
+        link = "<a href='#{license_link(Regexp.last_match(1), Regexp.last_match(2))}'>#{Regexp.last_match(3).strip}</a>"
+        output << link
       else
-       output << $3.strip
+        output << Regexp.last_match(3).strip
       end
-    output << "</div>"
-  end
+      output << '</div>'
+    end
 
-  def license_code_urls
-    {"cc"  => "http://creativecommons.org/licenses/",
-     "odc" => "http://opendatacommons.org/licenses/"}
-  end
+    def license_code_urls
+      { 'cc'  => 'http://creativecommons.org/licenses/',
+        'odc' => 'http://opendatacommons.org/licenses/' }
+    end
 
-  def license_link(code, type)
-    code = code.downcase
-    if license_code_urls.has_key?(code)
+    def license_link(code, type)
+      code = code.downcase
+      return unless license_code_urls.key?(code)
       "#{license_code_urls[code]}#{type.downcase}#{"/#{@config.cc_license_version}/" if code == 'cc'}"
     end
-  end
 
-  def access_label(element)
-    type = normalize_type(element)
-    if access_labels.has_key?(type)
-      return access_labels[type]
+    def access_label(element)
+      type = normalize_type(element)
+      return access_labels[type] if access_labels.key?(type)
+      I18n.t('mods_display.access_condition')
     end
-    I18n.t('mods_display.access_condition')
-  end
 
-  def normalize_type(element)
-    type = element.attributes["type"]
-    if type.respond_to?(:value)
-      return type.value.strip.gsub(/\s*/, "").downcase
+    def normalize_type(element)
+      type = element.attributes['type']
+      return type.value.strip.gsub(/\s*/, '').downcase if type.respond_to?(:value)
+      ''
     end
-    ""
-  end
 
-  def access_labels
-    {"useandreproduction"  => I18n.t('mods_display.use_and_reproduction'),
-     "restrictiononaccess" => I18n.t('mods_display.restriction_on_access'),
-     "copyright"           => I18n.t('mods_display.copyright'),
-     "license"             => I18n.t('mods_display.license')
-     }
+    def access_labels
+      { 'useandreproduction'  => I18n.t('mods_display.use_and_reproduction'),
+        'restrictiononaccess' => I18n.t('mods_display.restriction_on_access'),
+        'copyright'           => I18n.t('mods_display.copyright'),
+        'license'             => I18n.t('mods_display.license')
+       }
+    end
   end
-end
+end

data/lib/mods_display/fields/audience.rb

@@ -1,8 +1,9 @@
-class ModsDisplay::Audience < ModsDisplay::Field
+module ModsDisplay
+  class Audience < Field
+    private
 
-  private
-  def displayLabel(element)
-    super(element) || I18n.t('mods_display.target_audience')
+    def displayLabel(element)
+      super(element) || I18n.t('mods_display.target_audience')
+    end
   end
-
-end
+end

data/lib/mods_display/fields/cartographics.rb

@@ -1,21 +1,22 @@
-class ModsDisplay::Cartographics < ModsDisplay::Field
-
-  def fields
-    return nil if @values.nil?
-    return_fields = []
-    @values.each do |value|
-      if value.respond_to?(:cartographics)
+module ModsDisplay
+  class Cartographics < Field
+    def fields
+      return nil if @values.nil?
+      return_fields = []
+      @values.each do |value|
+        next unless value.respond_to?(:cartographics)
         value.cartographics.each do |field|
-          scale = field.scale.empty? ? "Scale not given" : field.scale.text
+          scale = field.scale.empty? ? 'Scale not given' : field.scale.text
           projection = field.projection.empty? ? nil : field.projection.text
           coordinates = field.coordinates.empty? ? nil : field.coordinates.text
-          post_scale = [projection, coordinates].compact.length > 0 ? [projection, coordinates].compact.join(" ") : nil
-          return_fields << ModsDisplay::Values.new({:label => (displayLabel(field) || label || I18n.t('mods_display.map_data')),
-                                                    :values => [[scale, post_scale].compact.join(" ; ")]})
+          post_scale = [projection, coordinates].compact.length > 0 ? [projection, coordinates].compact.join(' ') : nil
+          return_fields << ModsDisplay::Values.new(
+            label: (displayLabel(field) || label || I18n.t('mods_display.map_data')),
+            values: [[scale, post_scale].compact.join(' ; ')]
+          )
         end
       end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
   end
-
-end
+end

data/lib/mods_display/fields/collection.rb

@@ -1,21 +1,36 @@
-class ModsDisplay::Collection < ModsDisplay::Field
-
-  def label
-    super || I18n.t('mods_display.collection')
-  end
+module ModsDisplay
+  ###
+  #  Collection class to parse collection data out of Mods relatedItem fields
+  ###
+  class Collection < Field
+    def collection_label(value)
+      displayLabel(value) || I18n.t('mods_display.collection')
+    end
 
-  def fields
-    return_fields = []
-    @values.each do |value|
-      if value.respond_to?(:titleInfo) and
-         value.respond_to?(:typeOfResource) and
-         value.typeOfResource.attributes.length > 0 and
-         value.typeOfResource.attributes.first.has_key?("collection") and
-         value.typeOfResource.attributes.first["collection"].value == "yes"
-        return_fields << ModsDisplay::Values.new(:label => label, :values => [value.titleInfo.text.strip])
+    def fields
+      return_fields = []
+      @values.each do |value|
+        next unless related_item_is_a_collection?(value)
+        return_fields << ModsDisplay::Values.new(
+          label: collection_label(value),
+          values: [value.titleInfo.text.strip]
+        )
       end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
-  end
 
-end
+    private
+
+    def related_item_is_a_collection?(value)
+      value.respond_to?(:titleInfo) && resource_type_is_collection?(value)
+    end
+
+    def resource_type_is_collection?(value)
+      return unless value.respond_to?(:typeOfResource)
+      return unless value.typeOfResource.attributes.length > 0
+      value.typeOfResource.attributes.length > 0 &&
+        value.typeOfResource.attributes.first.key?('collection') &&
+        value.typeOfResource.attributes.first['collection'].value == 'yes'
+    end
+  end
+end

data/lib/mods_display/fields/contact.rb

@@ -1,17 +1,19 @@
-class ModsDisplay::Contact < ModsDisplay::Field
-  def fields
-    return_fields = contact_fields.map do |value|
-      ModsDisplay::Values.new(:label => displayLabel(value) || I18n.t('mods_display.contact'), :values => [value.text])
+module ModsDisplay
+  class Contact < Field
+    def fields
+      return_fields = contact_fields.map do |value|
+        ModsDisplay::Values.new(label: displayLabel(value) || I18n.t('mods_display.contact'), values: [value.text])
+      end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
-  end
 
-  private
-  def contact_fields
-    @values.select do |value|
-      value.attributes["type"].respond_to?(:value) and
-        value.attributes["type"].value.downcase == "contact"
+    private
+
+    def contact_fields
+      @values.select do |value|
+        value.attributes['type'].respond_to?(:value) &&
+          value.attributes['type'].value.downcase == 'contact'
+      end
     end
   end
-
-end
+end

data/lib/mods_display/fields/contents.rb

@@ -1,8 +1,9 @@
-class ModsDisplay::Contents < ModsDisplay::Field
+module ModsDisplay
+  class Contents < Field
+    private
 
-  private
-  def displayLabel(element)
-    super(element) || I18n.t('mods_display.table_of_contents')
+    def displayLabel(element)
+      super(element) || I18n.t('mods_display.table_of_contents')
+    end
   end
-
-end
+end

data/lib/mods_display/fields/description.rb

@@ -1,28 +1,28 @@
-class ModsDisplay::Description < ModsDisplay::Field
-
-  def fields
-    return_fields = description_fields.map do |value|
-      ModsDisplay::Values.new(:label => description_label(value), :values => [value.text])
+module ModsDisplay
+  class Description < Field
+    def fields
+      return_fields = description_fields.map do |value|
+        ModsDisplay::Values.new(label: description_label(value), values: [value.text])
+      end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
-  end
 
-  def description_label(element)
-    label || displayLabel(element) || labels[element.name.to_sym] || I18n.t('mods_display.physical_description')
-  end
+    def description_label(element)
+      label || displayLabel(element) || labels[element.name.to_sym] || I18n.t('mods_display.physical_description')
+    end
 
-  private
+    private
 
-  def description_fields
-    @values.children.select do |child|
-      labels.keys.include?(child.name.to_sym)
+    def description_fields
+      @values.children.select do |child|
+        labels.keys.include?(child.name.to_sym)
+      end
     end
-  end
 
-  def labels
-    {:digitalOrigin => I18n.t('mods_display.digital_origin'),
-     :note          => I18n.t('mods_display.note')
-     }
+    def labels
+      { digitalOrigin: I18n.t('mods_display.digital_origin'),
+        note: I18n.t('mods_display.note')
+       }
+    end
   end
-
-end
+end

data/lib/mods_display/fields/field.rb

@@ -1,140 +1,195 @@
 # encoding: utf-8
-class ModsDisplay::Field
-  def initialize(values, config, klass)
-    @values = values
-    @config = config
-    @klass = klass
-  end
+module ModsDisplay
+  class Field
+    def initialize(values, config, klass)
+      @values = values
+      @config = config
+      @klass = klass
+    end
 
-  def fields
-    return_fields = @values.map do |value|
-      ModsDisplay::Values.new(:label => displayLabel(value) || label, :values => [displayForm(@values) || value.text].flatten)
+    def fields
+      return_fields = @values.map do |value|
+        ModsDisplay::Values.new(
+          label: displayLabel(value) || label,
+          values: [displayForm(@values) || value.text].flatten
+        )
+      end
+      collapse_fields(return_fields)
     end
-    collapse_fields(return_fields)
-  end
 
-  def label
-    return nil if @values.nil?
-    displayLabel(@values.first)
-  end
+    def label
+      return nil if @values.nil?
+      displayLabel(@values.first)
+    end
 
-  def to_html
-    return nil if fields.empty? or @config.ignore?
-    output = ""
-    fields.each do |field|
-      if field.values.any?{|f| f && !f.empty? }
+    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>"
+        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
     end
-    output
-  end
 
-  private
+    private
 
-  def label_class
-    " class='#{@config.label_class}'" unless @config.label_class == ""
-  end
+    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 value_class
-    " class='#{@config.value_class}'" unless @config.value_class == ""
-  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 link_to_value(link_text, link_href=nil)
-    "<a href='#{@klass.send(@config.link[0], replace_tokens(@config.link[1], link_href || link_text))}'>#{link_text}</a>"
-  end
+    def date_is_bc_edtf?(date_field)
+      date_field.text.strip.start_with?('-') && date_is_edtf?(date_field)
+    end
 
-  def displayForm(element)
-    return element unless element # basically return nil
-    display = element.children.find{|c| c.name == "displayForm"}
-    return display.text if display
-  end
+    def date_is_ad?(date_field)
+      date_field.text.strip.gsub(/^0*/, '').length < 4
+    end
 
-  def displayLabel(element)
-    if (element.respond_to?(:attributes) and
-        element.attributes["displayLabel"].respond_to?(:value))
-      "#{element.attributes["displayLabel"].value}:"
+    def date_is_edtf?(date_field)
+      field_is_encoded?(date_field, 'edtf')
     end
-  end
 
-  def sanitized_field_title(label)
-    "title='#{label.gsub(/:$/,'').strip}'"
-  end
+    def field_is_encoded?(field, encoding)
+      field.attributes['encoding'] &&
+        field.attributes['encoding'].respond_to?(:value) &&
+        field.attributes['encoding'].value.downcase == encoding
+    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)
+    def ends_in_terminating_punctuation?(value)
+      value.strip.end_with?('.', ',', ':', ';')
     end
-    object
-  end
 
-  def replace_token(string, value)
-    string = string.dup
-    tokens.each do |token|
-      string.gsub!(token, value)
+    def label_class
+      " class='#{@config.label_class}'" unless @config.label_class == ''
     end
-    string
-  end
 
-  def tokens
-    ["%value%"]
-  end
+    def value_class
+      " class='#{@config.value_class}'" unless @config.value_class == ''
+    end
 
-  def link_urls_and_email(val)
-    val = val.dup
-    # http://daringfireball.net/2010/07/improved_regex_for_matching_urls
-    url = /(?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>")
+    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>"
+    end
+
+    def displayForm(element)
+      return element unless element # basically return nil
+      display = element.children.find { |c| c.name == 'displayForm' }
+      return display.text if display
+    end
+
+    def displayLabel(element)
+      return unless element.respond_to?(:attributes) &&
+                    element.attributes['displayLabel'].respond_to?(:value)
+      "#{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
-    val
-  end
 
-  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)
+    def replace_token(string, value)
+      string = string.dup
+      tokens.each do |token|
+        string.gsub!(token, value)
+      end
+      string
+    end
+
+    def tokens
+      ['%value%']
+    end
+
+    # 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
-      elsif prev_label and (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
+      val
+    end
+    # rubocop:enable Metrics/LineLength
+
+    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
+      end
+      return_values
     end
-    return_values
   end
-
-end
+end