bolognese 1.3.1 → 2.3.9

data/lib/bolognese/datacite_utils.rb

@@ -11,7 +11,13 @@ module Bolognese
     end
 
     def datacite_errors(xml: nil, schema_version: nil)
-      schema_version = schema_version.to_s.start_with?("http://datacite.org/schema/kernel") ? schema_version : "http://datacite.org/schema/kernel-4"
+      if xml.present?
+        namespaces = Nokogiri::XML(xml, nil, 'UTF-8').root.namespaces
+        schema_version = namespaces.fetch('xmlns',nil).presence || namespaces.fetch('xmlns:ns0',nil).presence
+      else
+        schema_version = schema_version.to_s.start_with?("http://datacite.org/schema/kernel") ? schema_version : "http://datacite.org/schema/kernel-4"
+      end
+
       kernel = schema_version.to_s.split("/").last
       filepath = File.expand_path("../../../resources/#{kernel}/metadata.xsd", __FILE__)
       schema = Nokogiri::XML::Schema(open(filepath))
@@ -28,11 +34,15 @@ module Bolognese
       insert_publisher(xml)
       insert_publication_year(xml)
       insert_resource_type(xml)
-      insert_alternate_identifiers(xml)
       insert_subjects(xml)
       insert_contributors(xml)
       insert_dates(xml)
+      insert_language(xml)
+      insert_alternate_identifiers(xml)
       insert_related_identifiers(xml)
+      insert_related_items(xml)
+      insert_sizes(xml)
+      insert_formats(xml)
       insert_version(xml)
       insert_rights_list(xml)
       insert_descriptions(xml)
@@ -59,7 +69,7 @@ module Bolognese
 
       xml.contributors do
         Array.wrap(contributors).each do |con|
-          xml.contributor("contributorType" => con["contributorType"] || "Other") do
+          xml.contributor("contributorType" => con["contributorType"]) do
             insert_person(xml, con, "contributor")
           end
         end
@@ -76,8 +86,8 @@ module Bolognese
         xml.nameIdentifier(ni["nameIdentifier"], 'nameIdentifierScheme' => ni["nameIdentifierScheme"], 'schemeURI' => ni["schemeUri"])
       end
       Array.wrap(person["affiliation"]).each do |affiliation|
-        attributes = { "affiliationIdentifierScheme" => affiliation["affiliationIdentifierScheme"], "schemeURI" => affiliation["schemeUri"] }.compact
-        xml.affiliation(affiliation["name"], attributes) 
+        attributes = { "affiliationIdentifier" => affiliation["affiliationIdentifier"], "affiliationIdentifierScheme" => affiliation["affiliationIdentifierScheme"], "schemeURI" => affiliation["schemeUri"] }.compact
+        xml.affiliation(affiliation["name"], attributes)
       end
     end
 
@@ -96,9 +106,19 @@ module Bolognese
         end
       end
     end
-
+    
     def insert_publisher(xml)
-      xml.publisher(publisher || container && container["title"])
+      if publisher.is_a?(Hash)
+        attributes = {
+          'publisherIdentifier' => publisher["publisherIdentifier"],
+          'publisherIdentifierScheme' => publisher["publisherIdentifierScheme"],
+          'schemeURI' => publisher["schemeUri"],
+          "xml:lang" => publisher["lang"]
+        }.compact
+        xml.publisher(publisher["name"] || container && container["title"], attributes)
+      else
+        xml.publisher(publisher || container && container["title"])
+      end
     end
 
     def insert_publication_year(xml)
@@ -108,7 +128,7 @@ module Bolognese
     def insert_resource_type(xml)
       return xml unless types.is_a?(Hash) && (types["schemaOrg"].present? || types["resourceTypeGeneral"])
 
-      xml.resourceType(types["resourceType"] || types["schemaOrg"],
+      xml.resourceType(types["resourceType"],
         'resourceTypeGeneral' => types["resourceTypeGeneral"] || Metadata::SO_TO_DC_TRANSLATIONS[types["schemaOrg"]] || "Other")
     end
 
@@ -161,7 +181,7 @@ module Bolognese
             s["subject"] = subject
           end
 
-          attributes = { "subjectScheme" => s["subjectScheme"], "schemeURI" => s["schemeUri"], "valueURI" => s["valueUri"], "xml:lang" => s["lang"] }.compact
+          attributes = { "subjectScheme" => s["subjectScheme"], "schemeURI" => s["schemeUri"], "valueURI" => s["valueUri"], "classificationCode" => s["classificationCode"], "xml:lang" => s["lang"] }.compact
 
           xml.subject(s["subject"], attributes)
         end
@@ -169,9 +189,16 @@ module Bolognese
     end
 
     def insert_version(xml)
-      return xml unless version.present?
+      return xml unless version_info.present?
 
-      xml.version(version)
+      xml.version(version_info)
+    end
+
+
+    def insert_language(xml)
+      return xml unless language.present?
+
+      xml.language(language)
     end
 
     def insert_related_identifiers(xml)
@@ -193,6 +220,93 @@ module Bolognese
       end
     end
 
+    def insert_related_items(xml)
+      return xml unless related_items.present?
+
+      xml.relatedItems do
+        related_items.each do |related_item|
+          attributes = {
+            'relatedItemType' => related_item["relatedItemType"],
+            'relationType' => related_item["relationType"],
+          }.compact
+
+          xml.relatedItem(related_item["relatedItem"], attributes) do
+
+            if related_item["relatedItemIdentifier"].present?
+              xml.relatedItemIdentifier(related_item["relatedItemIdentifier"]['relatedItemIdentifier'],
+                {
+                  'relatedItemIdentifierType' => related_item["relatedItemIdentifier"]["relatedItemIdentifierType"],
+                  'relatedMetadataScheme' => related_item["relatedItemIdentifier"]["relatedMetadataScheme"],
+                  'schemeURI' => related_item["relatedItemIdentifier"]["schemeURI"],
+                  'schemeType' => related_item["relatedItemIdentifier"]["schemeType"],
+                }.compact
+              )
+            end
+
+            if related_item["creators"].present?
+              xml.creators do
+                Array.wrap(related_item['creators']).each do |au|
+                  xml.creator do
+                    insert_person(xml, au, "creator")
+                  end
+                end
+              end
+            end
+
+            xml.titles do
+              Array.wrap(related_item['titles']).each do |title|
+                if title.is_a?(Hash)
+                  t = title
+                else
+                  t = {}
+                  t["title"] = title
+                end
+
+                attributes = { 'titleType' => t["titleType"], 'xml:lang' => t["lang"] }.compact
+                xml.title(t["title"], attributes)
+              end
+            end
+
+            xml.publicationYear(related_item['publicationYear']) if related_item["publicationYear"].present?
+            xml.volume(related_item['volume']) if related_item["volume"].present?
+            xml.issue(related_item['issue']) if related_item["issue"].present?
+            xml.number(related_item['number'], {'numberType' => related_item['numberType']}.compact) if related_item["number"].present?
+            xml.firstPage(related_item['firstPage']) if related_item["firstPage"].present?
+            xml.lastPage(related_item['lastPage']) if related_item["lastPage"].present?
+            xml.publisher(related_item['publisher']) if related_item["publisher"].present?
+            xml.edition(related_item['edition']) if related_item["edition"].present?
+
+            if related_item["contributors"].present?
+              xml.contributors do
+                Array.wrap(related_item["contributors"]).each do |con|
+                  xml.contributor("contributorType" => con["contributorType"] || "Other") do
+                    insert_person(xml, con, "contributor")
+                  end
+                end
+              end
+            end
+
+          end
+        end
+      end
+    end
+
+    def insert_sizes(xml)
+      xml.sizes do
+        Array.wrap(sizes).each do |s|
+          xml.size(s)
+        end
+      end
+    end
+
+    def insert_formats(xml)
+      xml.formats do
+        Array.wrap(formats).each do |f|
+          xml.format(f)
+        end
+      end
+    end
+
     def insert_rights_list(xml)
       return xml unless rights_list.present?
 
@@ -206,7 +320,13 @@ module Bolognese
             r["rightsUri"] = normalize_id(rights)
           end
 
-          attributes = { 'rightsURI' => r["rightsUri"], 'xml:lang' => r["lang"] }.compact
+          attributes = {
+            "rightsURI" => r["rightsUri"],
+            "rightsIdentifier" => r["rightsIdentifier"],
+            "rightsIdentifierScheme" => r["rightsIdentifierScheme"],
+            "schemeURI" => r["schemeUri"],
+            "xml:lang" => r["lang"]
+          }.compact
 
           xml.rights(r["rights"], attributes)
         end
@@ -264,13 +384,19 @@ module Bolognese
                 xml.northBoundLatitude(geo_location.dig("geoLocationBox", "northBoundLatitude"))
               end
             end
-
             if geo_location["geoLocationPolygon"]
               xml.geoLocationPolygon do
-                geo_location["geoLocationPolygon"].each do |polygon_point|
-                  xml.polygonPoint do
-                    xml.pointLatitude(polygon_point["pointLatitude"])
-                    xml.pointLongitude(polygon_point["pointLongitude"])
+                Array.wrap(geo_location["geoLocationPolygon"]).each do |polygon_point|
+                  if polygon_point.has_key?("polygonPoint")
+                    xml.polygonPoint do
+                      xml.pointLatitude(polygon_point.dig("polygonPoint", "pointLatitude"))
+                      xml.pointLongitude(polygon_point.dig("polygonPoint", "pointLongitude"))
+                    end
+                  else
+                    xml.inPolygonPoint do
+                      xml.pointLatitude(polygon_point.dig("inPolygonPoint", "pointLatitude"))
+                      xml.pointLongitude(polygon_point.dig("inPolygonPoint", "pointLongitude"))
+                    end
                   end
                 end
               end

data/lib/bolognese/doi_utils.rb

@@ -2,33 +2,38 @@
 
 module Bolognese
   module DoiUtils
+    class << self
+      include DoiUtils
+    end
+
     def validate_doi(doi)
-      doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(doi)).last
+      doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(doi)).last
       # remove non-printing whitespace and downcase
       doi.delete("\u200B").downcase if doi.present?
     end
 
     def validate_funder_doi(doi)
-      doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.13039\/)?(5.+)\z/.match(doi)).last
+      doi = Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.13039\/)?([1-9]\d+)\z/.match(doi)).last
+
       # remove non-printing whitespace and downcase
       if doi.present?
-        doi.delete("\u200B").downcase 
+        doi.delete("\u200B").downcase
         "https://doi.org/10.13039/#{doi}"
       end
     end
 
     def validate_prefix(doi)
-      Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}).*\z/.match(doi)).last
+      Array(/\A(?:(http|https):\/(\/)?(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}).*\z/.match(doi)).last
     end
 
     def doi_resolver(doi, options = {})
-      sandbox = Array(/handle.test.datacite.org/.match(doi)).last
-      sandbox.present? || options[:sandbox] ? "https://handle.test.datacite.org/" : "https://doi.org/"
+      sandbox = Array(/handle.stage.datacite.org/.match(doi)).last
+      sandbox.present? || options[:sandbox] ? "https://handle.stage.datacite.org/" : "https://doi.org/"
     end
 
     def doi_api_url(doi, options = {})
-      sandbox = Array(/handle.test.datacite.org/.match(doi)).last
-      sandbox.present? || options[:sandbox] ? "https://api.test.datacite.org/dois/" + doi_from_url(doi) : "https://api.datacite.org/dois/" + doi_from_url(doi)
+      sandbox = Array(/handle.stage.datacite.org/.match(doi)).last
+      sandbox.present? || options[:sandbox] ? "https://api.stage.datacite.org/dois/#{doi_from_url(doi)}?include=media,client"  : "https://api.datacite.org/dois/#{doi_from_url(doi)}?include=media,client"
     end
 
     def normalize_doi(doi, options = {})
@@ -40,7 +45,7 @@ module Bolognese
     end
 
     def doi_from_url(url)
-      if /\A(?:(http|https):\/\/(dx\.)?(doi.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(url)
+      if /\A(?:(http|https):\/\/(dx\.)?(doi.org|handle.stage.datacite.org|handle.test.datacite.org)\/)?(doi:)?(10\.\d{4,5}\/.+)\z/.match(url)
         uri = Addressable::URI.parse(url)
         uri.path.gsub(/^\//, '').downcase
       end

data/lib/bolognese/metadata.rb

@@ -6,21 +6,22 @@ module Bolognese
   class Metadata
     include Bolognese::MetadataUtils
 
-    attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue
+    attr_accessor :string, :from, :sandbox, :meta, :regenerate, :issue, :show_errors
     attr_reader :doc, :page_start, :page_end
-    attr_writer :id, :provider_id, :client_id, :doi, :identifiers, :creators, :contributors, :titles, :publisher, 
+    attr_writer :id, :provider_id, :client_id, :doi, :identifiers, :creators, :contributors, :titles, :publisher,
                 :rights_list, :dates, :publication_year, :volume, :url, :version_info,
                 :subjects, :contributor, :descriptions, :language, :sizes,
                 :formats, :schema_version, :meta, :container, :agency,
                 :format, :funding_references, :state, :geo_locations,
-                :types, :content_url, :related_identifiers, :style, :locale, :date_registered
+                :types, :content_url, :related_identifiers, :related_items, :style, :locale, :date_registered
 
-    def initialize(input: nil, from: nil, **options)
-      id = normalize_id(input, options)
+    def initialize(options={})
+      options.symbolize_keys!
+      id = normalize_id(options[:input], options)
       ra = nil
 
       if id.present?
-        @from = from || find_from_format(id: id)
+        @from = options[:from] || find_from_format(id: id)
 
         # mEDRA, KISTI, JaLC and OP DOIs are found in the Crossref index
         if @from == "medra"
@@ -36,10 +37,12 @@ module Bolognese
         # generate name for method to call dynamically
         hsh = @from.present? ? send("get_" + @from, id: id, sandbox: options[:sandbox]) : {}
         string = hsh.fetch("string", nil)
-      elsif input.present? && File.exist?(input)
-        ext = File.extname(input)
+
+      elsif options[:input].present? && File.exist?(options[:input])
+        filename = File.basename(options[:input])
+        ext = File.extname(options[:input])
         if %w(.bib .ris .xml .json).include?(ext)
-          hsh = { 
+          hsh = {
             "url" => options[:url],
             "state" => options[:state],
             "date_registered" => options[:date_registered],
@@ -47,14 +50,14 @@ module Bolognese
             "provider_id" => options[:provider_id],
             "client_id" => options[:client_id],
             "content_url" => options[:content_url] }
-          string = IO.read(input)
-          @from = from || find_from_format(string: string, ext: ext)
+          string = IO.read(options[:input])
+          @from = options[:from] || find_from_format(string: string, filename: filename, ext: ext)
         else
           $stderr.puts "File type #{ext} not supported"
           exit 1
         end
       else
-        hsh = { 
+        hsh = {
           "url" => options[:url],
           "state" => options[:state],
           "date_registered" => options[:date_registered],
@@ -67,8 +70,8 @@ module Bolognese
           "titles" => options[:titles],
           "publisher" => options[:publisher],
           "publication_year" => options[:publication_year] }
-        string = input
-        @from = from || find_from_format(string: string)
+        string = options[:input]
+        @from = options[:from] || find_from_format(string: string)
       end
 
       # make sure input is encoded as utf8
@@ -109,14 +112,15 @@ module Bolognese
         :language,
         :geo_locations,
         :related_identifiers,
+        :related_items,
         :formats,
         :sizes
       ).compact
 
       @regenerate = options[:regenerate] || read_options.present?
-
       # generate name for method to call dynamically
-      @meta = @from.present? ? send("read_" + @from, { string: string, sandbox: options[:sandbox], doi: options[:doi], id: id, ra: ra }.merge(read_options)) : {}
+      opts = { string: string, sandbox: options[:sandbox], doi: options[:doi], id: id, ra: ra }.merge(read_options)
+      @meta = @from.present? ? send("read_" + @from, **opts) : {}
     end
 
     def id
@@ -147,7 +151,7 @@ module Bolognese
     def errors
       meta.fetch("errors", nil) || datacite_errors(xml: datacite, schema_version: schema_version)
     end
-    
+
     def descriptions
       @descriptions ||= meta.fetch("descriptions", nil)
     end
@@ -184,12 +188,16 @@ module Bolognese
       @related_identifiers ||= meta.fetch("related_identifiers", nil)
     end
 
+    def related_items
+      @related_items ||= meta.fetch("related_items", nil)
+    end
+
     def url
       @url ||= meta.fetch("url", nil)
     end
 
     def version_info
-      @version_info ||= meta.fetch("version_info", nil)
+      @version_info ||= meta.fetch("version_info", nil) || meta.fetch("version", nil)
     end
 
     def publication_year
@@ -209,7 +217,7 @@ module Bolognese
     end
 
     def publisher
-      @publisher ||= meta.fetch("publisher", nil)
+      @publisher ||= normalize_publisher(meta["publisher"]) if meta.fetch("publisher", nil).present?
     end
 
     def identifiers

data/lib/bolognese/metadata_utils.rb

@@ -12,6 +12,7 @@ require_relative 'readers/crosscite_reader'
 require_relative 'readers/crossref_reader'
 require_relative 'readers/datacite_json_reader'
 require_relative 'readers/datacite_reader'
+require_relative 'readers/npm_reader'
 require_relative 'readers/ris_reader'
 require_relative 'readers/schema_org_reader'
 
@@ -45,6 +46,7 @@ module Bolognese
     include Bolognese::Readers::CrossrefReader
     include Bolognese::Readers::DataciteReader
     include Bolognese::Readers::DataciteJsonReader
+    include Bolognese::Readers::NpmReader
     include Bolognese::Readers::RisReader
     include Bolognese::Readers::SchemaOrgReader
 
@@ -94,7 +96,7 @@ module Bolognese
       if container.present?
         container["title"]
       elsif types["citeproc"] == "article-journal"
-        publisher
+        publisher["name"] if publisher.present?
       else
         nil
       end
@@ -106,12 +108,12 @@ module Bolognese
     end
 
     def reverse
-      { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsReferencedBy" }.map do |r| 
+      { "citation" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsReferencedBy" }.map do |r|
         { "@id" => normalize_doi(r["relatedIdentifier"]),
           "@type" => r["resourceTypeGeneral"] || "ScholarlyArticle",
           "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
         end.unwrap,
-        "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsSupplementTo" }.map do |r| 
+        "isBasedOn" => Array.wrap(related_identifiers).select { |ri| ri["relationType"] == "IsSupplementTo" }.map do |r|
           { "@id" => normalize_doi(r["relatedIdentifier"]),
             "@type" => r["resourceTypeGeneral"] || "ScholarlyArticle",
             "identifier" => r["relatedIdentifierType"] == "DOI" ? nil : to_identifier(r) }.compact
@@ -119,7 +121,15 @@ module Bolognese
     end
 
     def graph
+      # preload schema_org context
+      JSON::LD::Context.add_preloaded(
+        'http://schema.org/',
+        JSON::LD::Context.new.parse('resources/schema_org/jsonldcontext.json')
+      )
+
       RDF::Graph.new << JSON::LD::API.toRdf(schema_hsh)
+    rescue NameError
+      nil
     end
 
     def citeproc_hsh
@@ -130,14 +140,21 @@ module Bolognese
         author = to_citeproc(creators)
       end
 
+      if types["resourceTypeGeneral"] == "Software" && version_info.present?
+        type = "book"
+      else
+        type = types["citeproc"]
+      end
+
       {
-        "type" => types["citeproc"],
+        "type" => type,
         "id" => normalize_doi(doi),
         "categories" => Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.presence,
         "language" => language,
         "author" => author,
         "contributor" => to_citeproc(contributors),
-        "issued" => get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : nil,
+        "translator" => contributors ? to_citeproc(contributors.select { |c| c["contributorType"] == "Translator" }) : nil,
+        "issued" => get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : get_date_parts(publication_year.to_s),
         "submitted" => Array.wrap(dates).find { |d| d["dateType"] == "Submitted" }.to_h.fetch("__content__", nil),
         "abstract" => parse_attributes(descriptions, content: "description", first: true),
         "container-title" => container_title,
@@ -145,9 +162,10 @@ module Bolognese
         "volume" => container.to_h["volume"],
         "issue" => container.to_h["issue"],
         "page" => page,
-        "publisher" => publisher,
+        "publisher" => publisher["name"],
         "title" => parse_attributes(titles, content: "title", first: true),
         "URL" => url,
+        "copyright" => Array.wrap(rights_list).map { |l| l["rights"] }.first,
         "version" => version_info
       }.compact.symbolize_keys
     end
@@ -176,6 +194,7 @@ module Bolognese
         "geo_locations" => geo_locations,
         "funding_references" => funding_references,
         "related_identifiers" => related_identifiers,
+        "related_items" => related_items,
         "schema_version" => schema_version,
         "provider_id" => provider_id,
         "client_id" => client_id,

data/lib/bolognese/readers/bibtex_reader.rb

@@ -31,12 +31,13 @@ module Bolognese
 
         meta = string.present? ? BibTeX.parse(string).first : OpenStruct.new
 
-        schema_org = BIB_TO_SO_TRANSLATIONS[meta.try(:type).to_s] || "ScholarlyArticle"
+        bibtex_type = meta.try(:type).to_s
+        schema_org = BIB_TO_SO_TRANSLATIONS[bibtex_type] || "ScholarlyArticle"
         types = {
-          "resourceTypeGeneral" => Metadata::SO_TO_DC_TRANSLATIONS[schema_org],
+          "resourceTypeGeneral" => Metadata::BIB_TO_DC_TRANSLATIONS[bibtex_type],
           "resourceType" => Bolognese::Utils::BIB_TO_CR_TRANSLATIONS[meta.try(:type).to_s] || meta.try(:type).to_s,
           "schemaOrg" => schema_org,
-          "bibtex" => meta.type.to_s,
+          "bibtex" => bibtex_type,
           "citeproc" => BIB_TO_CP_TRANSLATIONS[meta.try(:type).to_s] || "misc",
           "ris" => BIB_TO_RIS_TRANSLATIONS[meta.try(:type).to_s] || "GEN"
         }.compact
@@ -50,53 +51,47 @@ module Bolognese
         end
 
         related_identifiers = if meta.try(:journal).present? && meta.try(:issn).to_s.presence
-          [{ "type" => "Periodical",
-             "relationType" => "IsPartOf",
-             "relatedIdentifierType" => "ISSN",
-             "title" => meta.journal.to_s,
-             "relatedIdentifier" => meta.try(:issn).to_s.presence }.compact]
-        else
-          nil
-        end
+                                [{ "type" => "Periodical",
+                                  "relationType" => "IsPartOf",
+                                  "relatedIdentifierType" => "ISSN",
+                                  "title" => meta.journal.to_s,
+                                  "relatedIdentifier" => meta.try(:issn).to_s.presence }.compact]
+                              end
 
         container = if meta.try(:journal).present?
-          first_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip)[0] : nil
-          last_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip)[1] : nil
-          
-          { "type" => "Journal",
-            "title" => meta.journal.to_s,
-            "identifier" => meta.try(:issn).to_s.presence,
-            "identifierType" => meta.try(:issn).present? ? "ISSN" : nil,
-            "volume" => meta.try(:volume).to_s.presence,
-            "firstPage" => first_page,
-            "lastPage" => last_page }.compact
-        else
-          nil
-        end
+                      first_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip)[0] : nil
+                      last_page = meta.try(:pages).present? ? meta.try(:pages).split("-").map(&:strip)[1] : nil
+
+                      { "type" => "Journal",
+                        "title" => meta.journal.to_s,
+                        "identifier" => meta.try(:issn).to_s.presence,
+                        "identifierType" => meta.try(:issn).present? ? "ISSN" : nil,
+                        "volume" => meta.try(:volume).to_s.presence,
+                        "firstPage" => first_page,
+                        "lastPage" => last_page }.compact
+                    end
 
         state = meta.try(:doi).to_s.present? || read_options.present? ? "findable" : "not_found"
-        dates = if meta.try(:date).present?
-          [{ "date" => meta.date.to_s,
-             "dateType" => "Issued" }]
-        else
-          nil
-        end
+        dates = if meta.try(:date).present? && Date.edtf(meta.date.to_s).present?
+                  [{ "date" => meta.date.to_s,
+                    "dateType" => "Issued" }]
+                end
         publication_year =  meta.try(:date).present? ? meta.date.to_s[0..3] : nil
+        rights_list = meta.try(:copyright).present? ? [hsh_to_spdx("rightsURI" => meta[:copyright])] : []
 
         { "id" => normalize_doi(doi),
           "types" => types,
-          "identifiers" => [{ "identifier" => normalize_doi(doi), "identifierType" => "DOI" }],
           "doi" => doi,
           "url" => meta.try(:url).to_s.presence,
           "titles" => meta.try(:title).present? ? [{ "title" => meta.try(:title).to_s }] : [],
           "creators" => creators,
           "container" => container,
-          "publisher" => meta.try(:publisher).to_s.presence,
+          "publisher" => meta.try(:publisher).present? ? { "name" => meta.publisher.to_s } : nil,
           "related_identifiers" => related_identifiers,
           "dates" => dates,
           "publication_year" => publication_year,
-          "descriptions" => meta.try(:abstract).present? ? [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s).presence, "descriptionType" => "Abstract" }] : [],
-          "rights_list" =>  meta.try(:copyright).present? ? [{ "rightsUri" => meta.try(:copyright).to_s.presence }.compact] : [],
+          "descriptions" => meta.try(:abstract).present? ? [{ "description" => meta.try(:abstract) && sanitize(meta.abstract.to_s, new_line: true).presence, "descriptionType" => "Abstract" }] : [],
+          "rights_list" => rights_list,
           "state" => state
         }.merge(read_options)
       end