bolognese 0.2.2 → 2.7.0

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "0.2.2"
+  VERSION = "2.7.0"
 end

data/lib/bolognese/whitelist_scrubber.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# modified from https://gist.github.com/ivan-kolmychek/ee2fdc53f3e2c637271d
+
+module Bolognese
+  class WhitelistScrubber < Loofah::Scrubber
+    def initialize(options={})
+      @direction = :bottom_up
+      @tags = options[:tags]
+      @attributes = options[:attributes]
+    end
+
+    def scrub(node)
+      scrub_node_attributes(node) and return CONTINUE if node_allowed?(node)
+      node.before node.children
+      node.remove
+    end
+
+    private
+
+    def scrub_node_attributes(node)
+      fallback_scrub_node_attributes(node) and return true unless @attributes.present? && @attributes.respond_to?(:include?)
+      node.attribute_nodes.each do |attr_node|
+        attr_node.remove unless @attributes.include?(attr_node.name)
+      end
+    end
+
+    def allowed_not_element_node_types
+      [ Nokogiri::XML::Node::TEXT_NODE, Nokogiri::XML::Node::CDATA_SECTION_NODE ]
+    end
+
+    def fallback_scrub_node_attributes(node)
+      Loofah::HTML5::Scrub.scrub_attributes(node)
+    end
+
+    def fallback_allowed_element_detection(node)
+      Loofah::HTML5::Scrub.allowed_element?(node.name)
+    end
+
+    def node_allowed?(node)
+      return fallback_allowed_element_detection(node) unless @tags.present? && @tags.respond_to?(:include?)
+      return true if allowed_not_element_node_types.include?(node.type)
+      return false unless node.type == Nokogiri::XML::Node::ELEMENT_NODE
+      @tags.include? node.name
+    end
+  end
+end

data/lib/bolognese/writers/bibtex_writer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module BibtexWriter
+      def bibtex
+        return nil unless valid?
+
+        pages = container.to_h["firstPage"].present? ? [container["firstPage"], container["lastPage"]].compact.join("-") : nil
+
+        bib = {
+          bibtex_type: types["bibtex"].presence || "misc",
+          bibtex_key: normalize_doi(doi),
+          doi: doi,
+          url: url,
+          author: authors_as_string(creators),
+          keywords: subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.join(", ") : nil,
+          language: language,
+          title: parse_attributes(titles, content: "title", first: true),
+          journal: container && container["title"],
+          volume: container.to_h["volume"],
+          issue: container.to_h["issue"],
+          pages: pages,
+          publisher: publisher["name"],
+          year: publication_year,
+          copyright: Array.wrap(rights_list).map { |l| l["rights"] }.first,
+        }.compact
+        BibTeX::Entry.new(bib).to_s
+      end
+    end
+  end
+end

data/lib/bolognese/writers/citation_writer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module CitationWriter
+      def citation
+        cp = CiteProc::Processor.new(style: style, locale: locale, format: 'html')
+        cp.import Array.wrap(citeproc_hsh)
+        bibliography = cp.render :bibliography, id: normalize_doi(doi)
+        bibliography.first
+      end
+    end
+  end
+end

data/lib/bolognese/writers/citeproc_writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module CiteprocWriter
+      def citeproc
+        JSON.pretty_generate citeproc_hsh.presence
+      end
+    end
+  end
+end

data/lib/bolognese/writers/codemeta_writer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module CodemetaWriter
+      def codemeta
+        return nil unless valid? || show_errors
+        
+        hsh = {
+          "@context" => id.present? ? "https://raw.githubusercontent.com/codemeta/codemeta/master/codemeta.jsonld" : nil,
+          "@type" => types.present? ? types["schemaOrg"] : nil,
+          "@id" => normalize_doi(doi),
+          "identifier" => to_schema_org_identifiers(identifiers),
+          "codeRepository" => url,
+          "name" => parse_attributes(titles, content: "title", first: true),
+          "authors" => creators,
+          "description" => parse_attributes(descriptions, content: "description", first: true),
+          "version" => version_info,
+          "tags" => subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) } : nil,
+          "datePublished" => get_date(dates, "Issued") || publication_year,
+          "dateModified" => get_date(dates, "Updated"),
+          "publisher" => publisher["name"],
+          "license" => Array.wrap(rights_list).map { |l| l["rightsUri"] }.compact.unwrap,
+        }.compact
+        JSON.pretty_generate hsh.presence
+      end
+    end
+  end
+end

data/lib/bolognese/writers/crosscite_writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module CrossciteWriter
+      def crosscite
+        JSON.pretty_generate crosscite_hsh.presence
+      end
+    end
+  end
+end

data/lib/bolognese/writers/crossref_writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module CrossrefWriter
+      def crossref
+        from == "crossref" ? raw : nil
+      end
+    end
+  end
+end

data/lib/bolognese/writers/csv_writer.rb

@@ -0,0 +1,24 @@
+module Bolognese
+  module Writers
+    module CsvWriter
+      require "csv"
+
+      def csv
+        bib = {
+          doi: doi,
+          url: url,
+          registered: get_iso8601_date(date_registered),
+          state: state,
+          resource_type_general: types.respond_to?(:to_h) ? types.to_h["resourceTypeGeneral"] : nil,
+          resource_type: types.respond_to?(:to_h) ? types.to_h["resourceType"] : nil,
+          title: parse_attributes(titles, content: "title", first: true),
+          author: authors_as_string(creators),
+          publisher: publisher.respond_to?(:to_h) ? publisher.to_h["name"] : nil,
+          publication_year: publication_year
+        }.values
+
+        CSV.generate { |csv| csv << bib }
+      end
+    end
+  end
+end

data/lib/bolognese/writers/datacite_json_writer.rb

@@ -0,0 +1,13 @@
+module Bolognese
+  # frozen_string_literal: true
+  
+  module Writers
+    module DataciteJsonWriter
+      def datacite_json
+        if crosscite_hsh.present?
+          JSON.pretty_generate crosscite_hsh.transform_keys! { |key| key.camelcase(uppercase_first_letter = :lower) }
+        end
+      end
+    end
+  end
+end

data/lib/bolognese/writers/datacite_writer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module DataciteWriter
+      # generate new DataCite XML version 4.0 if regenerate (!should_passthru) option is provided
+      def datacite
+        should_passthru ? raw : datacite_xml
+      end
+    end
+  end
+end

data/lib/bolognese/writers/jats_writer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module JatsWriter
+      def jats
+        @jats ||= Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+          xml.send("element-citation", publication_type) do
+            insert_citation(xml)
+          end
+        end.to_xml
+      end
+
+      def insert_citation(xml)
+        insert_authors(xml)
+        insert_editors(xml)
+        insert_citation_title(xml) if is_article? || is_data? || is_chapter?
+        insert_source(xml)
+        insert_publisher_name(xml) if publisher.present? && !is_data?
+        insert_publication_date(xml)
+        insert_volume(xml) if container.to_h["volume"].present?
+        insert_issue(xml) if container.to_h["issue"].present?
+        insert_fpage(xml) if container.to_h["firstPage"].present?
+        insert_lpage(xml) if container.to_h["lastPage"].present?
+        insert_version(xml) if version_info.present?
+        insert_pub_id(xml)
+      end
+
+      def is_article?
+        publication_type.fetch('publication-type', nil) == "journal"
+      end
+
+      def is_data?
+        publication_type.fetch('publication-type', nil) == "data"
+      end
+
+      def is_chapter?
+        publication_type.fetch('publication-type', nil) == "chapter"
+      end
+
+      def insert_authors(xml)
+        if creators.present?
+          xml.send("person-group", "person-group-type" => "author") do
+            Array.wrap(creators).each do |au|
+              xml.name do
+                insert_contributor(xml, au)
+              end
+            end
+          end
+        end
+      end
+
+      def insert_editors(xml)
+        if contributors.present?
+          xml.send("person-group", "person-group-type" => "editor") do
+            Array.wrap(contributors).each do |con|
+              xml.name do
+                insert_contributor(xml, con)
+              end
+            end
+          end
+        end
+      end
+
+      def insert_contributor(xml, person)
+        xml.surname(person["familyName"]) if person["familyName"].present?
+        xml.send("given-names", person["givenName"]) if person["givenName"].present?
+      end
+
+      def insert_citation_title(xml)
+        case publication_type.fetch('publication-type', nil)
+        when "data" then xml.send("data-title", parse_attributes(titles, content: "title", first: true))
+        when "journal" then xml.send("article-title", parse_attributes(titles, content: "title", first: true))
+        when "chapter" then xml.send("chapter-title", parse_attributes(titles, content: "title", first: true))
+        end
+      end
+
+      def insert_source(xml)
+        if is_chapter?
+          xml.source(publisher["name"])
+        elsif is_article? || is_data?
+          xml.source(container && container["title"] || publisher["name"])
+        else
+          xml.source(parse_attributes(titles, content: "title", first: true))
+        end
+      end
+
+      def insert_publisher_name(xml)
+        attributes = {
+          "xml:lang" => publisher["lang"]
+        }.compact
+        xml.send("publisher-name", attributes, publisher["name"])
+      end
+
+      def insert_publication_date(xml)
+        date = get_date(dates, "Issued") || publication_year
+        year, month, day = get_date_parts(date).to_h.fetch("date-parts", []).first
+
+        xml.year(year, "iso-8601-date" => date)
+        xml.month(month.to_s.rjust(2, '0')) if month.present?
+        xml.day(day.to_s.rjust(2, '0')) if day.present?
+      end
+
+      def insert_volume(xml)
+        xml.volume(container["volume"])
+      end
+
+      def insert_issue(xml)
+        xml.issue(container["issue"])
+      end
+
+      def insert_fpage(xml)
+        xml.fpage(container["firstPage"])
+      end
+
+      def insert_lpage(xml)
+        xml.lpage(container["lastPage"])
+      end
+
+      def insert_version(xml)
+        xml.version(version_info)
+      end
+
+      def insert_pub_id(xml)
+        return nil unless doi.present?
+        xml.send("pub-id", doi, "pub-id-type" => "doi")
+      end
+
+      def date
+        get_date(dates, "Issued") ? get_date_parts(get_date(dates, "Issued")) : get_date_parts(publication_year)
+      end
+
+      def publication_type
+        { 'publication-type' => Bolognese::Utils::CR_TO_JATS_TRANSLATIONS[types["resourceType"]] || Bolognese::Utils::SO_TO_JATS_TRANSLATIONS[types["schemaOrg"]] }.compact
+      end
+    end
+  end
+end

data/lib/bolognese/writers/rdf_xml_writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module RdfXmlWriter
+      def rdf_xml
+        graph.dump(:rdfxml, prefixes: { schema: "http://schema.org/" })
+      end
+    end
+  end
+end

data/lib/bolognese/writers/ris_writer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module RisWriter
+      def ris
+        {
+          "TY" => types["ris"],
+          "T1" => parse_attributes(titles, content: "title", first: true),
+          "T2" => container && container["title"],
+          "AU" => to_ris(creators),
+          "DO" => doi,
+          "UR" => url,
+          "AB" => parse_attributes(abstract_description, content: "description", first: true),
+          "KW" => Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.presence,
+          "PY" => publication_year,
+          "PB" => publisher["name"],
+          "LA" => language,
+          "VL" => container.to_h["volume"],
+          "IS" => container.to_h["issue"],
+          "SP" => container.to_h["firstPage"],
+          "EP" => container.to_h["lastPage"],
+          "SN" => Array.wrap(related_identifiers).find { |ri| ri["relationType"] == "IsPartOf" }.to_h.fetch("relatedIdentifier", nil),
+          "ER" => ""
+        }.compact.map { |k, v| v.is_a?(Array) ? v.map { |vi| "#{k}  - #{vi}" }.join("\r\n") : "#{k}  - #{v}" }.join("\r\n")
+      end
+    end
+  end
+end

data/lib/bolognese/writers/schema_org_writer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module SchemaOrgWriter
+      def schema_hsh
+        { "@context" => "http://schema.org",
+          "@type" => types.present? ? types["schemaOrg"] : nil,
+          "@id" => normalize_doi(doi),
+          "identifier" => to_schema_org_identifiers(identifiers),
+          "url" => url,
+          "additionalType" => types.present? ? types["resourceType"] : nil,
+          "name" => parse_attributes(titles, content: "title", first: true),
+          "author" => to_schema_org_creators(creators),
+          "editor" => to_schema_org_contributors(contributors),
+          "translator" => contributors ? to_schema_org_contributors(contributors.select { |c| c["contributorType"] == "Translator" }) : nil,
+          "description" => parse_attributes(abstract_description, content: "description", first: true),
+          "license" => Array.wrap(rights_list).map { |l| l["rightsUri"] }.compact.unwrap,
+          "version" => version_info,
+          "keywords" => subjects.present? ? Array.wrap(subjects).map { |k| parse_attributes(k, content: "subject", first: true) }.join(", ") : nil,
+          "inLanguage" => language,
+          "contentSize" => Array.wrap(sizes).unwrap,
+          "encodingFormat" => Array.wrap(formats).unwrap,
+          "dateCreated" => get_date(dates, "Created"),
+          "datePublished" => get_date(dates, "Issued") || publication_year,
+          "dateModified" => get_date(dates, "Updated"),
+          "temporalCoverage" => get_date(dates, "Coverage"),
+          "pageStart" => container.to_h["firstPage"],
+          "pageEnd" => container.to_h["lastPage"],
+          "spatialCoverage" => to_schema_org_spatial_coverage(geo_locations),
+          "sameAs" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "IsIdenticalTo"),
+          "isPartOf" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "IsPartOf"),
+          "hasPart" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "HasPart"),
+          "predecessor_of" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "IsPreviousVersionOf"),
+          "successor_of" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "IsNewVersionOf"),
+          "citation" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "References"),
+          "workTranslation" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "HasTranslation"),
+          "translationOfWork" => to_schema_org_relation(related_identifiers: related_identifiers, relation_type: "IsTranslationOf"),
+          "@reverse" => reverse.presence,
+          "contentUrl" => Array.wrap(content_url).unwrap,
+          "schemaVersion" => schema_version,
+          "periodical" => types.present? ? ((types["schemaOrg"] != "Dataset") && container.present? ? to_schema_org(container) : nil) : nil,
+          "includedInDataCatalog" => types.present? ? ((types["schemaOrg"] == "Dataset") && container.present? ? to_schema_org_container(container, type: "Dataset") : nil) : nil,
+          "publisher" => publisher.present? ? { "@type" => "Organization", "@id" => publisher["publisherIdentifier"], "name" => publisher["name"] }.compact : nil,
+          "funder" => to_schema_org_funder(funding_references),
+          "provider" => agency.present? ? { "@type" => "Organization", "name" => agency } : nil
+        }.compact.presence
+      end
+
+      def schema_org
+        JSON.pretty_generate schema_hsh
+      end
+    end
+  end
+end

data/lib/bolognese/writers/turtle_writer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bolognese
+  module Writers
+    module TurtleWriter
+      def turtle
+        graph.dump(:ttl, prefixes: { schema: "http://schema.org/" })
+      end
+    end
+  end
+end

data/lib/bolognese.rb

@@ -1,12 +1,27 @@
+# frozen_string_literal: true
+
 require 'active_support/all'
 require 'nokogiri'
 require 'maremma'
-require 'postrank-uri'
+require 'bibtex'
+require 'loofah'
+require 'json/ld'
+require 'rdf/turtle'
+require 'rdf/rdfxml'
+require 'logger'
+require 'iso8601'
+require 'jsonlint'
+require 'gender_detector'
+require 'citeproc'
+require 'csl/styles'
+require 'edtf'
 
+require "bolognese/citeproc_extensions"
 require "bolognese/version"
 require "bolognese/metadata"
-require "bolognese/crossref"
-require "bolognese/datacite"
-require "bolognese/orcid"
 require "bolognese/cli"
 require "bolognese/string"
+require "bolognese/array"
+require "bolognese/whitelist_scrubber"
+
+ENV['USER_AGENT'] ||= "Mozilla/5.0 (compatible; Maremma/#{Maremma::VERSION}; mailto:info@datacite.org)"

data/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "edam-browser",
+  "description": "The EDAM Browser is a client-side web-based visualization javascript widget. Its goals are to help describing bio-related resources and service with EDAM, and to facilitate and foster community contributions to EDAM.",
+  "author": "Bryan Brancotte",
+  "version": "1.0.0",
+  "scripts": {
+    "test": "jshint js/*js"
+  },
+  "devDependencies": {
+    "jshint": "^2.9.5"
+  }
+}