mods_display 0.1.3 → 0.1.4

data/lib/mods_display/fields/access_condition.rb

@@ -0,0 +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)])
+    end
+    collapse_fields(return_fields)
+  end
+
+  private
+
+  def process_access_statement(element)
+    case normalize_type(element)
+    when "copyright"
+      copyright_statement(element)
+    when "license"
+      license_statement(element)
+    else
+      element.text
+    end
+  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>"
+      else
+       output << $3.strip
+      end
+    output << "</div>"
+  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)
+      "#{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]
+    end
+    "Access condition"
+  end
+
+  def normalize_type(element)
+    type = element.attributes["type"]
+    if type.respond_to?(:value)
+      return type.value.strip.gsub(/\s*/, "").downcase
+    end
+    ""
+  end
+
+  def access_labels
+    {"useandreproduction"  => "Use and reproduction",
+     "restrictiononaccess" => "Restriction on access",
+     "copyright"           => "Copyright",
+     "license"             => "License"
+     }
+  end
+end

data/lib/mods_display/fields/description.rb

@@ -20,9 +20,7 @@ class ModsDisplay::Description < ModsDisplay::Field
   end
 
   def labels
-    {:form          => "Form",
-     :extent        => "Extent",
-     :digitalOrigin => "Digital origin",
+    {:digitalOrigin => "Digital origin",
      :note          => "Note"
      }
   end

data/lib/mods_display/fields/format.rb

@@ -1,29 +1,36 @@
 class ModsDisplay::Format < ModsDisplay::Field
 
   def fields
-    return [] if @values.text.strip.empty?
-    return_fields = @values.map do |value|
-      ModsDisplay::Values.new(:label => displayLabel(value) || "Format", :values => [displayForm(value) || value.text])
+    return_fields = []
+    # if @values.respond_to?(:format) and
+    #    !@values.format.nil? and
+    #    !@values.format.empty?
+    #      return_fields << ModsDisplay::Values.new(:label => "Format",
+    #                                               :values => [decorate_formats(@values.format).join(", ")])
+    # end
+    unless @values.physical_description.nil?
+      @values.physical_description.each do |description|
+        unless description.form.nil? or description.form.empty?
+          return_fields << ModsDisplay::Values.new(:label  => displayLabel(description) || "Format",
+                                                   :values => [description.form.map{|f| f.text.strip }.uniq.join(", ")])
+        end
+        unless description.extent.nil? or description.extent.empty?
+          return_fields << ModsDisplay::Values.new(:label  => displayLabel(description) || "Format",
+                                                   :values => [description.extent.map{|e| e.text }.join(", ")])
+        end
+      end
     end
     collapse_fields(return_fields)
   end
 
-  def to_html
-    return nil if @config.ignore?
-    output = ""
-    fields.each do |field|
-      output << "<dt#{label_class} title='#{field.label}'>#{field.label}:</dt>"
-      output << "<dd#{value_class}>"
-        field.values.map do |val|
-          output << "<span class='#{self.class.format_class(val)}'>#{val}</span>"
-        end.join(@config.delimiter)
-      output << "</dd>"
+  private
+
+  def decorate_formats(formats)
+    formats.map do |format|
+      "<span data-mods-display-format='#{self.class.format_class(format)}'>#{format}</span>"
     end
-    output
   end
 
-  private
-
   def self.format_class(format)
     return format if format.nil?
     format.strip.downcase.gsub(/\/|\\|\s+/, "_")

data/lib/mods_display/fields/genre.rb

@@ -1,8 +1,14 @@
 class ModsDisplay::Genre < ModsDisplay::Field
 
+  def fields
+    return_fields = @values.map do |value|
+      ModsDisplay::Values.new(:label => displayLabel(value) || label, :values => [value.text.strip.capitalize].flatten)
+    end
+    collapse_fields(return_fields)
+  end
 
   private
-  
+
   def displayLabel(element)
     super(element) || "Genre"
   end

data/lib/mods_display/fields/identifier.rb

@@ -27,6 +27,7 @@ class ModsDisplay::Identifier < ModsDisplay::Field
      "ismn"                      => "ISMN",
      "issue number"              => "Issue number",
      "lccn"                      => "LCCN",
+     "oclc"                      => "OCLC",
      "matrix number"             => "Matrix number",
      "music publisher"           => "Music publisher",
      "music plate"               => "Music plate",

data/lib/mods_display/fields/imprint.rb

@@ -1,5 +1,5 @@
 class ModsDisplay::Imprint < ModsDisplay::Field
-
+  include ModsDisplay::CountryCodes
   def fields
     return_fields = []
     @values.each do |value|
@@ -58,7 +58,21 @@ class ModsDisplay::Imprint < ModsDisplay::Field
     end.compact
   end
   def parse_dates(date_field)
-    apply_date_qualifier_decoration dedup_dates join_date_ranges date_field
+    apply_date_qualifier_decoration dedup_dates join_date_ranges process_encoded_dates ignore_bad_dates date_field
+  end
+  def ignore_bad_dates(date_fields)
+    date_fields.select do |date_field|
+      date_field.text.strip != "9999"
+    end
+  end
+  def process_encoded_dates(date_fields)
+    date_fields.map do |date_field|
+      if date_is_w3cdtf?(date_field)
+        process_w3cdtf_date(date_field)
+      else
+        date_field
+      end
+    end
   end
   def join_date_ranges(date_fields)
     if dates_are_range?(date_fields)
@@ -135,6 +149,22 @@ class ModsDisplay::Imprint < ModsDisplay::Field
     attributes.include?("start") and
     attributes.include?("end")
   end
+  def date_is_w3cdtf?(date_field)
+    date_field.attributes["encoding"] and
+    date_field.attributes["encoding"].respond_to?(:value) and
+    date_field.attributes["encoding"].value.downcase == "w3cdtf"
+  end
+  def process_w3cdtf_date(date_field)
+    date_field = date_field.clone
+    date_field.content = if date_field.text.strip =~ /^\d{4}-\d{2}-\d{2}$/
+      Date.parse(date_field.text).strftime(@config.full_date_format)
+    elsif date_field.text.strip =~ /^\d{4}-\d{2}$/
+      Date.parse("#{date_field.text}-01").strftime(@config.short_date_format)
+    else
+      date_field.content
+    end
+    date_field
+  end
   def dedup_dates(date_fields)
     date_text = date_fields.map{|d| normalize_date(d.text) }
     if date_text != date_text.uniq
@@ -160,11 +190,30 @@ class ModsDisplay::Imprint < ModsDisplay::Field
   def place_terms(element)
     return [] unless element.respond_to?(:place) and
                      element.place.respond_to?(:placeTerm)
-    element.place.placeTerm.select do |term|
-      !term.attributes["type"] or
+    if unencoded_place_terms?(element)
+      element.place.placeTerm.select do |term|
+        !term.attributes["type"].respond_to?(:value) or
+         term.attributes["type"].value == "text"
+      end.compact
+    else
+      element.place.placeTerm.map do |term|
+        if term.attributes["type"].respond_to?(:value) and
+           term.attributes["type"].value == "code" and
+           term.attributes["authority"].respond_to?(:value) and
+           term.attributes["authority"].value == "marccountry" and
+           country_codes.include?(term.text.strip)
+             term = term.clone
+             term.content = country_codes[term.text.strip]
+             term
+        end
+      end.compact
+    end
+  end
+  def unencoded_place_terms?(element)
+    element.place.placeTerm.any? do |term|
       !term.attributes["type"].respond_to?(:value) or
-       term.attributes["type"].value != "code"
-    end.compact
+             term.attributes["type"].value == "text"
+    end
   end
   def imprint_display_form(element)
     display_form = element.children.find do |child|

data/lib/mods_display/fields/location.rb

@@ -1,13 +1,35 @@
 class ModsDisplay::Location < ModsDisplay::Field
 
+  def fields
+    return_fields = []
+    @values.each do |location|
+      location.children.each do |child|
+        if location_field_keys.include? child.name.to_sym
+          if child.name.to_sym == :url
+            loc_label = displayLabel(location) || "Location"
+            value = "<a href='#{child.text}'>#{displayLabel(child) || child.text}</a>"
+          else
+            loc_label = location_label(child) || displayLabel(location) || "Location"
+            value = child.text
+          end
+          return_fields << ModsDisplay::Values.new(:label  => loc_label || displayLabel(location) || "Location",
+                                                   :values => [value])
+        end
+      end
+    end
+    collapse_fields(return_fields)
+  end
+
   private
 
-  def displayLabel(element)
-    super(element) || location_label(element) || "Location"
+  def location_field_keys
+    [:physicalLocation, :url, :shelfLocation, :holdingSimple, :holdingExternal]
   end
 
   def location_label(element)
-    if element.attributes["type"].respond_to?(:value) && location_labels.has_key?(element.attributes["type"].value)
+    if displayLabel(element)
+      displayLabel(element)
+    elsif element.attributes["type"].respond_to?(:value) && location_labels.has_key?(element.attributes["type"].value)
       location_labels[element.attributes["type"].value]
     end
   end

data/lib/mods_display/fields/name.rb

@@ -1,22 +1,13 @@
 class ModsDisplay::Name < ModsDisplay::Field
-
+  include ModsDisplay::RelatorCodes
   def fields
     return_fields = @values.map do |value|
-      role = nil
+      role = process_role(value)
       person = nil
-      if value.role.length > 0 and value.role.roleTerm.length > 0
-        role = value.role.roleTerm.find do |term|
-          term.attributes["type"].respond_to?(:value) and
-          term.attributes["type"].value == "text"
-        end
-      end
       if value.displayForm.length > 0
         person = ModsDisplay::Name::Person.new(:name => value.displayForm.text, :role => role)
-      else
-        name_parts = value.namePart.map do |name_part|
-          name_part.text
-        end.join(", ")
-        person = ModsDisplay::Name::Person.new(:name => name_parts, :role => role) unless name_parts.empty?
+      elsif !name_parts(value).empty?
+        person = ModsDisplay::Name::Person.new(:name => name_parts(value), :role => role)
       end
       ModsDisplay::Values.new(:label => displayLabel(value) || name_label(value), :values => [person]) if person
     end.compact
@@ -64,6 +55,84 @@ class ModsDisplay::Name < ModsDisplay::Field
     end
   end
 
+  def name_parts(element)
+    output = ""
+    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 = ", "
+      if name_part_begins_with_roman_numeral?(terms.first)
+        term_delimiter = " "
+      end
+      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
+  end
+
+  def unqualified_name_parts(element)
+    element.namePart.map do |part|
+      part.text unless part.attributes["type"]
+    end.compact
+  end
+
+  def qualified_name_parts(element, type)
+    element.namePart.map do |part|
+      if part.attributes["type"].respond_to?(:value) and
+         part.attributes["type"].value == type
+           part.text
+      end
+    end.compact
+  end
+
+  def name_part_begins_with_roman_numeral?(part)
+    first_part = part.split(/\s|,/).first.strip
+    first_part.chars.all? do |char|
+      ["I", "X", "C", "L", "V"].include? char
+    end
+  end
+
+  def process_role(element)
+    if element.role.length > 0 and element.role.roleTerm.length > 0
+      if unencoded_role_term?(element)
+        unencoded_role_term(element)
+      else
+        element.role.roleTerm.map do |term|
+          if term.attributes["type"].respond_to?(:value) and
+             term.attributes["type"].value == "code" and
+             term.attributes["authority"].respond_to?(:value) and
+             term.attributes["authority"].value == "marcrelator" and
+             relator_codes.include?(term.text.strip)
+               term = term.clone
+               term.content = relator_codes[term.text.strip]
+               term
+          end
+        end.compact.first
+      end
+    end
+  end
+
+  def unencoded_role_term(element)
+    element.role.roleTerm.find do |term|
+      term.attributes["type"].respond_to?(:value) and
+      term.attributes["type"].value == "text"
+    end || element.role.roleTerm.find do |term|
+      !term.attributes["type"].respond_to?(:value)
+    end
+  end
+
+  def unencoded_role_term?(element)
+    element.role.roleTerm.any? do |term|
+      !term.attributes["type"].respond_to?(:value) or
+       term.attributes["type"].value == "text"
+    end
+  end
+
   def name_labels
     {"personal"   => "Author/Creator",
      "corporate"  => "Corporate author",

data/lib/mods_display/fields/related_item.rb

@@ -2,24 +2,83 @@ class ModsDisplay::RelatedItem < ModsDisplay::Field
 
   def fields
     return_fields = @values.map do |value|
-      unless (value.typeOfResource.length > 0 and
-              value.typeOfResource.attributes.length > 0 and
-              value.typeOfResource.attributes.first.has_key?("collection") and
-              value.typeOfResource.attributes.first["collection"].value == "yes")
-        if value.titleInfo.length > 0
-          title = value.titleInfo.text.strip
-          return_text = title
-          location = nil
-          location = value.location.url.text if (value.location.length > 0 and
-                                                 value.location.url.length > 0)
-          return_text = "<a href='#{location}'>#{title}</a>" if location and !title.empty?
-          unless return_text.empty?
-            ModsDisplay::Values.new(:label => displayLabel(value) || "Related item", :values => [return_text])
-          end
+      unless related_item_is_a_collection?(value)
+        case
+          when related_item_is_a_location?(value)
+            process_location value
+          when related_item_is_a_reference?(value)
+            process_reference value
+          else
+            process_related_item(value)
         end
       end
     end.compact
     collapse_fields(return_fields)
   end
 
+  private
+
+  def process_location(item)
+    ModsDisplay::Values.new(:label => related_item_label(item), :values => [item.location.text.strip])
+  end
+
+  def process_reference(item)
+    ModsDisplay::Values.new(:label => related_item_label(item), :values => [reference_title(item)])
+  end
+
+  def process_related_item(item)
+    if item.titleInfo.length > 0
+      title = item.titleInfo.text.strip
+      return_text = title
+      location = nil
+      location = item.location.url.text if (item.location.length > 0 and
+                                            item.location.url.length > 0)
+      return_text = "<a href='#{location}'>#{title}</a>" if location and !title.empty?
+      unless return_text.empty?
+        ModsDisplay::Values.new(:label => related_item_label(item), :values => [return_text])
+      end
+    end
+  end
+
+  def reference_title(item)
+    [item.titleInfo,
+     item.originInfo.dateOther,
+     item.part.detail.number,
+     item.note].flatten.compact.map!(&:text).map!(&:strip).join(" ")
+  end
+
+  def related_item_is_a_collection?(item)
+    item.respond_to?(:titleInfo) and
+    item.respond_to?(:typeOfResource) and
+    item.typeOfResource.attributes.length > 0 and
+    item.typeOfResource.attributes.first.has_key?("collection") and
+    item.typeOfResource.attributes.first["collection"].value == "yes"
+  end
+
+  def related_item_is_a_location?(item)
+    !related_item_is_a_collection?(item) and
+    !related_item_is_a_reference?(item) and
+     item.location.length > 0 and
+     item.titleInfo.length < 1
+  end
+
+  def related_item_is_a_reference?(item)
+    !related_item_is_a_collection?(item) and
+     item.attributes["type"].respond_to?(:value) and
+     item.attributes["type"].value == "isReferencedBy"
+  end
+
+  def related_item_label(item)
+    if displayLabel(item)
+      return displayLabel(item)
+    else
+      case
+      when related_item_is_a_location?(item)
+        return "Location"
+      when related_item_is_a_reference?(item)
+        return "Referenced by"
+      end
+      "Related item"
+    end
+  end
 end