bolognese 0.2.2 → 2.7.0

data/lib/bolognese/readers/datacite_json_reader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module DataciteJsonReader
+      def read_datacite_json(string: nil, **options)
+        errors = jsonlint(string)
+        return { "errors" => errors } if errors.present?
+
+        datacite_json = string.present? ? Maremma.from_json(string).transform_keys! { |key| key.underscore } : {}
+        datacite_json["publisher"] = normalize_publisher(datacite_json["publisher"]) if datacite_json.fetch("publisher", nil).present?
+
+        datacite_json
+      end
+    end
+  end
+end

data/lib/bolognese/readers/datacite_reader.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Bolognese
+  module Readers
+    module DataciteReader
+      def get_datacite(id: nil, **options)
+        return { "string" => nil, "state" => "not_found" } unless id.present?
+
+        api_url = doi_api_url(id, options)
+        response = Maremma.get(api_url)
+        attributes = response.body.dig("data", "attributes")
+        return { "string" => nil, "state" => "not_found" } unless attributes.present?
+
+        string = attributes.fetch('xml', nil)
+        string = Base64.decode64(string) if string.present?
+
+        if string.present?
+          doc = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks)
+
+          # remove leading and trailing whitespace in text nodes
+          doc.xpath("//text()").each do |node|
+            if node.content =~ /\S/
+              node.content = node.content.strip
+            else
+              node.remove
+            end
+          end
+          string = doc.to_xml(:indent => 2)
+        end
+
+        client = Array.wrap(response.body.fetch("included", nil)).find { |m| m["type"] == "clients" }
+        client_id = client.to_h.fetch("id", nil)
+        provider_id = Array.wrap(client.to_h.fetch("relationships", nil)).find { |m| m["provider"].present? }.to_h.dig("provider", "data", "id")
+
+        content_url = attributes.fetch("contentUrl", nil) || Array.wrap(response.body.fetch("included", nil)).select { |m| m["type"] == "media" }.map do |m|
+          m.dig("attributes", "url")
+        end.compact
+
+        { "string" => string,
+          "url" => attributes.fetch("url", nil),
+          "state" => attributes.fetch("state", nil),
+          "date_registered" => attributes.fetch("registered", nil),
+          "date_updated" => attributes.fetch("updated", nil),
+          "provider_id" => provider_id,
+          "client_id" => client_id,
+          "content_url" => content_url }
+      end
+
+      def read_datacite(string: nil, **options)
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        doc = Nokogiri::XML(string, nil, 'UTF-8', &:noblanks)
+        if read_options.present?
+          schema_version = "http://datacite.org/schema/kernel-4"
+        else
+          ns = doc.collect_namespaces.find { |k, v| v.start_with?("http://datacite.org/schema/kernel") }
+          schema_version = Array.wrap(ns).last || "http://datacite.org/schema/kernel-4"
+        end
+        doc.remove_namespaces!
+        string = doc.to_xml(:indent => 2)
+
+        meta = Maremma.from_xml(string).to_h.fetch("resource", {})
+
+        # validate only when option is set, as this step is expensive and
+        # not needed if XML comes from DataCite MDS
+        if options[:validate]
+          errors = datacite_errors(xml: string, schema_version: schema_version)
+          return { "errors" => errors } if errors.present?
+        end
+
+        if options[:doi]
+          id = normalize_doi(options[:doi], sandbox: options[:sandbox])
+        else
+          id = normalize_doi(meta.dig("identifier", "__content__") || options[:id], sandbox: options[:sandbox])
+        end
+
+        identifiers = Array.wrap(meta.dig("alternateIdentifiers", "alternateIdentifier")).map do |r|
+          if r["__content__"].present?
+            { "identifierType" => get_identifier_type(r["alternateIdentifierType"]), "identifier" => r["__content__"] }
+          end
+        end.compact
+
+        resource_type_general = meta.dig("resourceType", "resourceTypeGeneral")
+        resource_type = meta.dig("resourceType", "__content__")
+        schema_org = Bolognese::Utils::CR_TO_SO_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_SO_TRANSLATIONS[resource_type_general.to_s.dasherize] || "CreativeWork"
+        types = {
+          "resourceTypeGeneral" => resource_type_general,
+          "resourceType" => resource_type,
+          "schemaOrg" => schema_org,
+          "citeproc" => Bolognese::Utils::CR_TO_CP_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_CP_TRANSLATIONS[schema_org] || "article",
+          "bibtex" => Bolognese::Utils::CR_TO_BIB_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::SO_TO_BIB_TRANSLATIONS[schema_org] || "misc",
+          "ris" => Bolognese::Utils::CR_TO_RIS_TRANSLATIONS[resource_type.to_s.underscore.camelcase] || Bolognese::Utils::DC_TO_RIS_TRANSLATIONS[resource_type_general.to_s.dasherize] || "GEN"
+        }.compact
+
+        titles = get_titles(meta)
+
+        publisher = Array.wrap(meta.dig("publisher")).map do |r|
+          if r.blank?
+            nil
+          elsif r.is_a?(String)
+            { "name" => r.strip }
+          elsif r.is_a?(Hash)
+            {
+              "name" => r["__content__"].present? ? r["__content__"].strip : nil,
+              "publisherIdentifier" => r["publisherIdentifierScheme"] == "ROR" ? normalize_ror(r["publisherIdentifier"]) : r["publisherIdentifier"],
+              "publisherIdentifierScheme" => r["publisherIdentifierScheme"],
+              "schemeUri" => r["schemeURI"],
+              "lang" => r["lang"],
+            }.compact
+          end
+        end.compact.first
+
+        descriptions = Array.wrap(meta.dig("descriptions", "description")).map do |r|
+          if r.blank?
+            nil
+          elsif r.is_a?(String)
+            { "description" => sanitize(r, new_line: true), "descriptionType" => "Abstract" }
+          elsif r.is_a?(Hash)
+            { "description" => sanitize(r["__content__"], new_line: true), "descriptionType" => r["descriptionType"], "lang" => r["lang"] }.compact
+          end
+        end.compact
+        rights_list = Array.wrap(meta.dig("rightsList", "rights")).map do |r|
+          if r.blank?
+            nil
+          elsif r.is_a?(String)
+            name_to_spdx(r)
+          elsif r.is_a?(Hash)
+            hsh_to_spdx(r)
+          end
+        end.compact
+
+        subjects = Array.wrap(meta.dig("subjects", "subject")).reduce([]) do |sum, subject|
+          if subject.is_a?(String)
+            sum += name_to_subject(subject)
+          elsif subject.is_a?(Hash)
+            sum += hsh_to_subject(subject)
+          end
+
+          sum
+        end.uniq
+
+        dates = Array.wrap(meta.dig("dates", "date")).map do |r|
+          if r.is_a?(Hash) && date = sanitize(r["__content__"]).presence
+            { "date" => date,
+              "dateType" => parse_attributes(r, content: "dateType"),
+              "dateInformation" => parse_attributes(r, content: "dateInformation")
+            }.compact
+          end
+        end.compact
+        sizes = Array.wrap(meta.dig("sizes", "size")).map do |k|
+          if k.blank?
+            nil
+          elsif k.is_a?(String)
+            sanitize(k).presence
+          elsif k.is_a?(Hash)
+            sanitize(k["__content__"]).presence
+          end
+        end.compact
+        formats = Array.wrap(meta.dig("formats", "format")).map do |k|
+          if k.blank?
+            nil
+          elsif k.is_a?(String)
+            sanitize(k).presence
+          elsif k.is_a?(Hash)
+            sanitize(k["__content__"]).presence
+          end
+        end.compact
+        .map { |s| s.to_s.squish.presence }.compact
+        funding_references = Array.wrap(meta.dig("fundingReferences", "fundingReference")).compact.map do |fr|
+          scheme_uri = parse_attributes(fr["funderIdentifier"], content: "schemeURI")
+          funder_identifier = parse_attributes(fr["funderIdentifier"])
+          funder_identifier_type = parse_attributes(fr["funderIdentifier"], content: "funderIdentifierType")
+
+          if funder_identifier_type == "Crossref Funder ID"
+            funder_identifier = validate_funder_doi(funder_identifier)
+          elsif funder_identifier_type == "ROR"
+            funder_identifier = normalize_ror(funder_identifier)
+          else
+            funder_identifier = normalize_id(funder_identifier) ? normalize_id(funder_identifier) : funder_identifier
+          end
+
+          {
+            "funderName" => fr["funderName"],
+            "funderIdentifier" => funder_identifier,
+            "funderIdentifierType" => funder_identifier_type,
+            "schemeUri" => scheme_uri,
+            "awardNumber" => parse_attributes(fr["awardNumber"]),
+            "awardUri" => parse_attributes(fr["awardNumber"], content: "awardURI"),
+            "awardTitle" => fr["awardTitle"] }.compact
+        end
+        related_identifiers = Array.wrap(meta.dig("relatedIdentifiers", "relatedIdentifier")).map do |ri|
+          if ri["relatedIdentifierType"] == "DOI"
+            doi = ri["__content__"].to_s.downcase
+            rid = validate_doi(doi) || doi
+          else
+            rid = ri["__content__"]
+          end
+
+          {
+            "relatedIdentifier" => rid,
+            "relatedIdentifierType" => ri["relatedIdentifierType"],
+            "relationType" => ri["relationType"],
+            "resourceTypeGeneral" => ri["resourceTypeGeneral"],
+            "relatedMetadataScheme" => ri["relatedMetadataScheme"],
+            "schemeUri" => ri["schemeURI"],
+            "schemeType" => ri["schemeType"],
+            "relationTypeInformation" => ri["relationTypeInformation"]
+          }.compact
+        end
+
+        related_items = Array.wrap(meta.dig("relatedItems", "relatedItem")).map do |ri|
+
+          rii = ri["relatedItemIdentifier"]
+          relatedItemIdentifier = nil
+          if rii
+            if rii["relatedItemIdentifierType"] == "DOI"
+              doi = rii["__content__"].to_s.downcase
+              rid = validate_doi(doi) || doi
+            else
+              rid = rii["__content__"]
+            end
+
+            relatedItemIdentifier = {
+              "relatedItemIdentifier" => rid,
+              "relatedItemIdentifierType" => rii["relatedItemIdentifierType"],
+              "relatedMetadataScheme" => rii["relatedMetadataScheme"],
+              "schemeURI" => rii["schemeURI"],
+              "schemeType" => rii["schemeType"],
+            }.compact
+          end
+
+          number = ri["number"]
+          if number.is_a?(String)
+            number = number
+          else
+            number = ri.dig("number", "__content__")
+            numberType = ri.dig("number", "numberType")
+          end
+
+          a = {
+            "relationType" => ri["relationType"],
+            "relationTypeInformation" => ri["relationTypeInformation"],
+            "relatedItemType" => ri["relatedItemType"],
+            "relatedItemIdentifier" => relatedItemIdentifier,
+            "creators" => get_authors(Array.wrap(ri.dig("creators", "creator"))),
+            "titles" => get_titles(ri),
+            "publicationYear" => ri["publicationYear"],
+            "volume" => parse_attributes(ri["volume"]),
+            "issue" => parse_attributes(ri["issue"]),
+            "number" => number,
+            "numberType" => numberType,
+            "firstPage" => parse_attributes(ri["firstPage"]),
+            "lastPage" => parse_attributes(ri["lastPage"]),
+            "publisher" => parse_attributes(ri["publisher"]),
+            "edition" => parse_attributes(ri["edition"]),
+            "contributors" => get_authors(Array.wrap(ri.dig("contributors", "contributor"))),
+          }.compact
+        end
+
+        geo_locations = Array.wrap(meta.dig("geoLocations", "geoLocation")).map do |gl|
+          if !gl.is_a?(Hash) || gl["geoLocationPoint"].is_a?(String) || gl["geoLocationBox"].is_a?(String) || gl["geoLocationPolygon"].is_a?(String)
+            nil
+          else
+            ## Array of geoLocationPolygons within a geoLocation is Unsupported in JSON.
+            if gl.dig("geoLocationPolygon").kind_of?(Array)
+              geoLocationPolygon = nil
+            else
+              geoLocationPolygon = Array.wrap(gl.dig("geoLocationPolygon", "polygonPoint")).map { |glp| { "polygonPoint" => glp } }
+                .push(Array.wrap(gl.dig("geoLocationPolygon", "inPolygonPoint")).map { |glp| { "inPolygonPoint" => glp } }.first)
+                .compact.presence             
+            end
+
+            {
+              "geoLocationPoint" => {
+                "pointLatitude" => gl.dig("geoLocationPoint", "pointLatitude"),
+                "pointLongitude" => gl.dig("geoLocationPoint", "pointLongitude")
+              }.compact.presence,
+              "geoLocationBox" => {
+                "westBoundLongitude" => gl.dig("geoLocationBox", "westBoundLongitude"),
+                "eastBoundLongitude" => gl.dig("geoLocationBox", "eastBoundLongitude"),
+                "southBoundLatitude" => gl.dig("geoLocationBox", "southBoundLatitude"),
+                "northBoundLatitude" => gl.dig("geoLocationBox", "northBoundLatitude")
+              }.compact.presence,
+              "geoLocationPolygon" => geoLocationPolygon,
+              "geoLocationPlace" => parse_attributes(gl["geoLocationPlace"], first: true).to_s.strip.presence
+            }.compact
+          end
+        end.compact
+
+        state = id.present? || read_options.present? ? "findable" : "not_found"
+
+        { "id" => id,
+          "types" => types,
+          "doi" => doi_from_url(id),
+          "identifiers" => identifiers,
+          "url" => options.fetch(:url, nil).to_s.strip.presence,
+          "titles" => titles,
+          "creators" => get_authors(Array.wrap(meta.dig("creators", "creator"))),
+          "contributors" => get_authors(Array.wrap(meta.dig("contributors", "contributor"))),
+          "publisher" => publisher,
+          "agency" => "datacite",
+          "funding_references" => funding_references,
+          "dates" => dates,
+          "publication_year" => parse_attributes(meta.fetch("publicationYear", nil), first: true).to_s.strip.presence,
+          "descriptions" => descriptions,
+          "rights_list" => Array.wrap(rights_list),
+          "version_info" => meta.fetch("version", nil).to_s.presence,
+          "subjects" => subjects,
+          "language" => parse_attributes(meta.fetch("language", nil), first: true).to_s.strip.presence,
+          "geo_locations" => geo_locations,
+          "related_identifiers" => related_identifiers,
+          "related_items" => related_items,
+          "formats" => formats,
+          "sizes" => sizes,
+          "schema_version" => schema_version,
+          "state" => state
+        }.merge(read_options)
+      end
+
+      def get_titles(meta)
+        titles = Array.wrap(meta.dig("titles", "title")).map do |r|
+          if r.blank?
+            nil
+          elsif r.is_a?(String)
+            { "title" => sanitize(r) }
+          else
+            { "title" => sanitize(r["__content__"]), "titleType" => r["titleType"], "lang" => r["lang"] }.compact
+          end
+        end.compact
+
+        titles
+      end
+
+    end
+  end
+end

data/lib/bolognese/readers/npm_reader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module NpmReader
+      def get_npm(id: nil, **options)
+        return { "string" => nil, "state" => "not_found" } unless id.present?
+        id = normalize_id(id)
+        response = Maremma.get(id, accept: "json", raw: true)
+        string = response.body.fetch("data", nil)
+
+        { "string" => string }
+      end
+
+      def read_npm(string: nil, **options)
+        if string.present?
+          errors = jsonlint(string)
+          return { "errors" => errors } if errors.present?
+        end
+
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = string.present? ? Maremma.from_json(string) : {}
+
+        types = {
+          "resourceTypeGeneral" => "Software",
+          "reourceType" => "NPM Package",
+          "schemaOrg" => "SoftwareSourceCode",
+          "citeproc" => "article",
+          "bibtex" => "misc",
+          "ris" => "GEN"
+        }.compact
+
+        creators = if meta.fetch("author", nil).present?
+          get_authors(Array.wrap(meta.fetch("author", nil)))
+        else
+          [{ "nameType" => "Organizational", "name" => ":(unav)" }]
+        end
+        # contributors = get_authors(from_citeproc(Array.wrap(meta.fetch("editor", nil))))
+        # dates = if date = get_date_from_date_parts(meta.fetch("issued", nil))
+        #           if Date.edtf(date).present?
+        #             [{ "date" => date,
+        #               "dateType" => "Issued" }]
+        #           end
+        #         end
+        # publication_year = get_date_from_date_parts(meta.fetch("issued", nil)).to_s[0..3]
+        rights_list = if meta.fetch("license", nil)
+                        [{ "rights" => meta.fetch("license") }.compact]
+                      end
+        # related_identifiers = if meta.fetch("container-title", nil).present? && meta.fetch("ISSN", nil).present?
+        #                         [{ "type" => "Periodical",
+        #                           "relationType" => "IsPartOf",
+        #                           "relatedIdentifierType" => "ISSN",
+        #                           "title" => meta.fetch("container-title", nil),
+        #                           "relatedIdentifier" => meta.fetch("ISSN", nil) }.compact]
+        #                       end
+        # container = if meta.fetch("container-title", nil).present?
+        #   first_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[0] : nil
+        #   last_page = meta.fetch("page", nil).present? ? meta.fetch("page").split("-").map(&:strip)[1] : nil
+
+        #   { "type" => "Periodical",
+        #     "title" => meta.fetch("container-title", nil),
+        #     "identifier" => meta.fetch("ISSN", nil),
+        #     "identifierType" => meta.fetch("ISSN", nil).present? ? "ISSN" : nil,
+        #     "volume" => meta.fetch("volume", nil),
+        #     "issue" => meta.fetch("issue", nil),
+        #     "firstPage" => first_page,
+        #     "lastPage" => last_page
+        #    }.compact
+        # else
+        #   nil
+        # end
+
+        # identifiers = [normalize_id(meta.fetch("id", nil)), normalize_doi(meta.fetch("DOI", nil))].compact.map do |r|
+        #   r = normalize_id(r)
+
+        #   if r.start_with?("https://doi.org")
+        #     { "identifierType" => "DOI", "identifier" => r }
+        #   else
+        #       { "identifierType" => "URL", "identifier" => r }
+        #   end
+        # end.uniq
+
+        # id = Array.wrap(identifiers).first.to_h.fetch("identifier", nil)
+        # doi = Array.wrap(identifiers).find { |r| r["identifierType"] == "DOI" }.to_h.fetch("identifier", nil)
+          
+        # state = id.present? || read_options.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("keywords", nil)).map do |s|
+          { "subject" => s }
+        end
+
+        { 
+          #"id" => id,
+          #"identifiers" => identifiers,
+          "types" => types,
+          #"doi" => doi_from_url(doi),
+          #"url" => normalize_id(meta.fetch("URL", nil)),
+          "titles" => [{ "title" => meta.fetch("name", nil) }],
+          "creators" => creators,
+          #"contributors" => contributors,
+          #"container" => container,
+          #"publisher" => meta.fetch("publisher", nil),
+          #"related_identifiers" => related_identifiers,
+          #"dates" => dates,
+          #"publication_year" => publication_year,
+          "descriptions" => meta.fetch("description", nil).present? ? [{ "description" => sanitize(meta.fetch("description"), new_line: true), "descriptionType" => "Abstract" }] : [],
+          "rights_list" => rights_list,
+          "version_info" => meta.fetch("version", nil),
+          "subjects" => subjects
+          #"state" => state
+        }.merge(read_options)
+      end
+    end
+  end
+end

data/lib/bolognese/readers/ris_reader.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Readers
+    module RisReader
+      RIS_TO_SO_TRANSLATIONS = {
+        "BLOG" => "BlogPosting",
+        "GEN" => "CreativeWork",
+        "CTLG" => "DataCatalog",
+        "DATA" => "Dataset",
+        "FIGURE" => "ImageObject",
+        "THES" => "Thesis",
+        "MPCT" => "Movie",
+        "JOUR" => "ScholarlyArticle",
+        "COMP" => "SoftwareSourceCode",
+        "VIDEO" => "VideoObject",
+        "ELEC" => "WebPage"
+      }
+
+      RIS_TO_CP_TRANSLATIONS = {
+        "JOUR" => "article-journal"
+      }
+
+      RIS_TO_BIB_TRANSLATIONS = {
+        "JOUR" => "article",
+        "BOOK" => "book",
+        "CHAP" => "inbook",
+        "CPAPER" => "inproceedings",
+        "GEN" => "misc",
+        "THES" => "phdthesis",
+        "CONF" => "proceedings",
+        "RPRT" => "techreport",
+        "UNPD" => "unpublished"
+      }
+
+      def read_ris(string: nil, **options)
+        read_options = ActiveSupport::HashWithIndifferentAccess.new(options.except(:doi, :id, :url, :sandbox, :validate, :ra))
+
+        meta = ris_meta(string: string)
+
+        ris_type = meta.fetch("TY", nil) || "GEN"
+        schema_org = RIS_TO_SO_TRANSLATIONS[ris_type] || "CreativeWork"
+        types = {
+          "resourceTypeGeneral" => Metadata::RIS_TO_DC_TRANSLATIONS[ris_type],
+          "schemaOrg" => schema_org,
+          "citeproc" => RIS_TO_CP_TRANSLATIONS[schema_org] || "misc",
+          "ris" => ris_type
+        }.compact
+
+        id = normalize_doi(options[:doi] || meta.fetch("DO", nil))
+
+        author = Array.wrap(meta.fetch("AU", nil)).map { |a| { "creatorName" => a } }
+        date_parts = meta.fetch("PY", nil).to_s.split("/")
+        created_date_parts = meta.fetch("Y1", nil).to_s.split("/")
+        dates = []
+        dates << { "date" => get_date_from_parts(*date_parts), "dateType" => "Issued" } if meta.fetch("PY", nil).present?
+        dates << { "date" => get_date_from_parts(*created_date_parts), "dateType" => "Created" } if meta.fetch("Y1", nil).present?
+        publication_year = get_date_from_parts(*date_parts).to_s[0..3]
+        related_identifiers = if meta.fetch("T2", nil).present? && meta.fetch("SN", nil).present?
+          [{ "type" => "Periodical",
+             "id" => meta.fetch("SN", nil),
+             "relatedIdentifierType" => "ISSN",
+             "relationType" => "IsPartOf",
+             "title" => meta.fetch("T2", nil), }.compact]
+        else
+          []
+        end
+        container = if meta.fetch("T2", nil).present?
+          { "type" => "Journal",
+            "title" => meta.fetch("T2", nil),
+            "identifier" => meta.fetch("SN", nil),
+            "volume" => meta.fetch("VL", nil),
+            "issue" => meta.fetch("IS", nil),
+            "firstPage" => meta.fetch("SP", nil),
+            "lastPage" => meta.fetch("EP", nil) }.compact
+        else
+          nil
+        end
+        state = meta.fetch("DO", nil).present? || read_options.present? ? "findable" : "not_found"
+        subjects = Array.wrap(meta.fetch("KW", nil)).reduce([]) do |sum, subject|
+          sum += name_to_subject(subject)
+
+          sum
+        end
+
+        { "id" => id,
+          "types" => types,
+          "doi" => doi_from_url(id),
+          "url" => meta.fetch("UR", nil),
+          "titles" => meta.fetch("T1", nil).present? ? [{ "title" => meta.fetch("T1", nil) }] : nil,
+          "creators" => get_authors(author),
+          "publisher" => { "name" => meta.fetch("PB", "(:unav)") },
+          "container" => container,
+          "related_identifiers" => related_identifiers,
+          "dates" => dates,
+          "publication_year" => publication_year,
+          "descriptions" => meta.fetch("AB", nil).present? ? [{ "description" => sanitize(meta.fetch("AB"), new_line: true), "descriptionType" => "Abstract" }] : nil,
+          "subjects" => subjects,
+          "language" => meta.fetch("LA", nil),
+          "state" => state
+        }.merge(read_options)
+      end
+
+      def ris_meta(string: nil)
+        h = Hash.new { |h,k| h[k] = [] }
+        string.split("\n").reduce(h) do |sum, line|
+          k, v = line.split("-",2)
+          h[k.strip] << v.to_s.strip
+          sum
+        end.map { |k,v| [k, v.unwrap] }.to_h.compact
+      end
+    end
+  end
+end