bolognese 0.7 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 510d880a02cea7933abd7de597f9a4061dad981b
-  data.tar.gz: 754fa0b49a23494efa1cac66c99688313bbaafca
+  metadata.gz: e529a85cd30e24af04203358d96f53dfe7c17526
+  data.tar.gz: 588daf5d103c64b25e4c06709dc6815c32f67587
 SHA512:
-  metadata.gz: 9899dd154362fea725898b2895664704b1f6cdb7a981fd10225094b29273e467f45c45e545fd966ff06451df107c9625e906438172fac0fc44e55608e96165bb
-  data.tar.gz: ba1af6c6cdc58219234ea03e7a989a8eb464fee854fe581ad280465d942db5212113a99e65c23d876e6642c3345d79ff5bdb7ec82c94bbc9a8709acb594eb803
+  metadata.gz: b0d7078349cd7b70cf40e996099c1017b9dbf9487580236aa8c8fa974ef28dc61ad7508ccf827c4ee9ea0a7fdd9c51ba9fa9e37554ecb807ab17a7bca8ee9673
+  data.tar.gz: 2772cbe1d11e52aa3835279161e826552dc3ddda889109d460d8a79996f94202784b689ce65172a9ee0af08c2e65f51d8dbd99a3e01a152f86231e400e65f9f4

data/.gitignore

@@ -1,3 +1,4 @@
+.DS_Store
 *.gem
 *.rbc
 /.config

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bolognese (0.7)
+    bolognese (0.7.1)
       activesupport (~> 4.2, >= 4.2.5)
       bibtex-ruby (~> 4.1)
       builder (~> 3.2, >= 3.2.2)

data/README.md

@@ -868,6 +868,70 @@ bolognese https://blog.datacite.org/eating-your-own-dog-food -t bibtex
 }
 ```
 
+Convert Codemeta to schema.org/JSON-LD:
+
+```
+bolognese https://github.com/datacite/maremma
+
+{  
+  "@context":"http://schema.org",
+  "@type":"SoftwareSourceCode",
+  "@id":"https://doi.org/10.5438/qeg0-3gm3",
+  "url":"https://github.com/datacite/maremma",
+  "name":"Maremma: a Ruby library for simplified network calls",
+  "author":{  
+    "@type":"person",
+    "@id":"http://orcid.org/0000-0003-0077-4738",
+    "name":"Martin Fenner"
+  },
+  "description":"Simplifies network calls, including json/xml parsing and error handling. Based on Faraday.",
+  "keywords":"faraday, excon, net/http",
+  "dateCreated":"2015-11-28",
+  "datePublished":"2017-02-24",
+  "dateModified":"2017-02-24",
+  "publisher":{  
+    "@type":"Organization",
+    "name":"DataCite"
+  }
+}
+```
+
+Convert Codemeta to DataCite XML:
+
+```
+bolognese https://github.com/datacite/maremma -t datacite
+
+<?xml version="1.0" encoding="UTF-8"?>
+<resource xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://datacite.org/schema/kernel-4" xsi:schemaLocation="http://datacite.org/schema/kernel-4 http://schema.datacite.org/meta/kernel-4/metadata.xsd">
+  <identifier identifierType="DOI">10.5438/qeg0-3gm3</identifier>
+  <creators>
+    <creator>
+      <creatorName>Martin Fenner</creatorName>
+      <nameIdentifier schemeURI="http://orcid.org/" nameIdentifierScheme="ORCID">http://orcid.org/0000-0003-0077-4738</nameIdentifier>
+    </creator>
+  </creators>
+  <titles>
+    <title>Maremma: a Ruby library for simplified network calls</title>
+  </titles>
+  <publisher>DataCite</publisher>
+  <publicationYear>2017</publicationYear>
+  <resourceType resourceTypeGeneral="Software">SoftwareSourceCode</resourceType>
+  <subjects>
+    <subject>faraday</subject>
+    <subject>excon</subject>
+    <subject>net/http</subject>
+  </subjects>
+  <dates>
+    <date dateType="Created">2015-11-28</date>
+    <date dateType="Issued">2017-02-24</date>
+    <date dateType="Updated">2017-02-24</date>
+  </dates>
+  <descriptions>
+    <description descriptionType="Abstract">Simplifies network calls, including json/xml parsing and error handling. Based on Faraday.</description>
+  </descriptions>
+</resource>
+```
+
 ## Development
 
 We use rspec for unit testing:

data/lib/bolognese/author_utils.rb

@@ -58,5 +58,17 @@ module Bolognese
 
       "http://orcid.org/" + name_identifier
     end
+
+    def authors_as_string(authors)
+      Array.wrap(authors).map do |a|
+        if a["@type"] == "organization"
+          "{" + a["name"] + "}"
+        elsif a["familyName"].present?
+          [a["familyName"], a["givenName"]].join(", ")
+        else
+          a["name"]
+        end
+      end.join(" and ").presence
+    end
   end
 end

data/lib/bolognese/cli.rb

@@ -33,13 +33,14 @@ module Bolognese
         from = options[:from] || find_from_format(id: id)
       else
         ext = File.extname(input)
-        if %w(.bib .xml).include? ext
+        filename = File.basename(input)
+        if %w(.bib .xml).include?(ext) || filename == "codemeta.json"
           string = IO.read(input)
         else
           $stderr.puts "File type #{ext} not supported"
           exit 1
         end
-        from = options[:from] || find_from_format(string: string, ext: ext)
+        from = options[:from] || find_from_format(string: string, ext: ext, filename: filename)
       end
 
       to = options[:to] || "schema_org"

data/lib/bolognese/codemeta.rb

@@ -7,7 +7,7 @@ module Bolognese
       if string.present?
         @raw = string
       elsif id.present?
-        response = Maremma.get(id, accept: "application/ld+json", raw: true)
+        response = Maremma.get(github_as_codemeta_url(id), raw: true)
         @raw = response.body.fetch("data", nil)
       end
     end
@@ -64,8 +64,8 @@ module Bolognese
     end
 
     def author
-      a = Array.wrap(metadata.fetch("agents", nil)).map { |a| a.extract!("@type", "@id", "name") }
-      array_unwrap(a)
+      arr = Array.wrap(metadata.fetch("agents", nil)).map { |a| a.slice("@type", "@id", "name") }
+      array_unwrap(arr)
     end
 
     def editor

data/lib/bolognese/crossref.rb

@@ -172,23 +172,23 @@ module Bolognese
 
     def people(contributor_role)
       person = bibliographic_metadata.dig("contributors", "person_name")
-      a = Array.wrap(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
+      arr = Array.wrap(person).select { |a| a["contributor_role"] == contributor_role }.map do |a|
         { "@type" => "Person",
           "@id" => parse_attributes(a["ORCID"]),
           "givenName" => a["given_name"],
           "familyName" => a["surname"] }.compact
       end
-      array_unwrap(a)
+      array_unwrap(arr)
     end
 
     def funder
       fundref = Array.wrap(program_metadata).find { |a| a["name"] == "fundref" } || {}
-      a = Array.wrap(fundref.fetch("assertion", [])).select { |a| a["name"] == "fundgroup" }.map do |f|
+      arr = Array.wrap(fundref.fetch("assertion", [])).select { |a| a["name"] == "fundgroup" }.map do |f|
         { "@type" => "Organization",
           "@id" => normalize_id(f.dig("assertion", "assertion", "__content__")),
           "name" => f.dig("assertion", "__content__").strip }.compact
       end
-      array_unwrap(a)
+      array_unwrap(arr)
     end
 
     def date_published

data/lib/bolognese/datacite.rb

@@ -187,13 +187,13 @@ module Bolognese
     end
 
     def related_identifiers(relation_type)
-      a = Array.wrap(metadata.dig("relatedIdentifiers", "relatedIdentifier"))
+      arr = Array.wrap(metadata.dig("relatedIdentifiers", "relatedIdentifier"))
         .select { |r| relation_type.split(" ").include?(r["relationType"]) && %w(DOI URL).include?(r["relatedIdentifierType"]) }
         .map do |work|
           { "@type" => "CreativeWork",
             "@id" => normalize_id(work["__content__"]) }
         end
-      array_unwrap(a)
+      array_unwrap(arr)
     end
 
     def same_as

data/lib/bolognese/metadata.rb

@@ -28,11 +28,6 @@ module Bolognese
       [page_start, page_end].compact.join("-").presence
     end
 
-    def author_string
-      Array.wrap(author).map { |a| [a["familyName"], a["givenName"]].join(", ") }
-                        .join(" and ").presence
-    end
-
     def publisher_string
       publisher.to_h.fetch("name", nil)
     end
@@ -96,7 +91,7 @@ module Bolognese
         bibtex_key: id,
         doi: doi,
         url: url,
-        author: author_string,
+        author: authors_as_string(author),
         keywords: keywords,
         language: language,
         title: name,

data/lib/bolognese/schema_org.rb

@@ -62,13 +62,13 @@ module Bolognese
     end
 
     def author
-      a = Array.wrap(metadata.fetch("author", nil)).map { |a| a.except("name") }
-      array_unwrap(a)
+      arr = Array.wrap(metadata.fetch("author", nil)).map { |a| a.except("name") }
+      array_unwrap(arr)
     end
 
     def editor
-      a = Array.wrap(metadata.fetch("editor", nil)).map { |a| a.except("name") }
-      array_unwrap(a)
+      arr = Array.wrap(metadata.fetch("editor", nil)).map { |a| a.except("name") }
+      array_unwrap(arr)
     end
 
     def description

data/lib/bolognese/utils.rb

@@ -1,11 +1,11 @@
 module Bolognese
   module Utils
 
-    def find_from_format(id: nil, string: nil, ext: nil)
+    def find_from_format(id: nil, string: nil, ext: nil, filename: nil)
       if id.present?
         find_from_format_by_id(id)
       elsif string.present?
-        find_from_format_by_string(string, ext: ext)
+        find_from_format_by_string(string, ext: ext, filename: filename)
       end
     end
 
@@ -16,6 +16,8 @@ module Bolognese
         get_doi_ra(id).fetch("id", nil)
       elsif /\A(?:(http|https):\/\/orcid\.org\/)?(\d{4}-\d{4}-\d{4}-\d{3}[0-9X]+)\z/.match(id)
         "orcid"
+      elsif /\A(http|https):\/\/github\.com\/(.+)\z/.match(id)
+        "codemeta"
       else
         "schema_org"
       end
@@ -24,10 +26,12 @@ module Bolognese
     def find_from_format_by_string(string, options={})
       if options[:ext] == ".bib"
         "bibtex"
-      elsif Maremma.from_xml(string).dig("doi_records", "doi_record", "crossref")
+      elsif options[:ext] == ".xml" && Maremma.from_xml(string).dig("doi_records", "doi_record", "crossref")
         "crossref"
-      elsif Maremma.from_xml(string).dig("resource", "xmlns") == "http://datacite.org/schema/kernel-4"
+      elsif options[:ext] == ".xml" && Maremma.from_xml(string).dig("resource", "xmlns") == "http://datacite.org/schema/kernel-4"
         "datacite"
+      elsif options[:filename] == "codemeta.json"
+        "codemeta"
       end
     end
 
@@ -36,6 +40,7 @@ module Bolognese
         p = case from
             when "crossref" then Crossref.new(id: id, string: string)
             when "datacite" then Datacite.new(id: id, string: string, schema_version: options[:schema_version])
+            when "codemeta" then Codemeta.new(id: id, string: string)
             when "bibtex" then Bibtex.new(string: string)
             else SchemaOrg.new(id: id)
             end
@@ -104,8 +109,49 @@ module Bolognese
     end
 
     def normalize_ids(list)
-      a = Array.wrap(list).map { |url| url.merge("@id" => normalize_id(url["@id"])) }
-      array_unwrap(a)
+      arr = Array.wrap(list).map { |url| url.merge("@id" => normalize_id(url["@id"])) }
+      array_unwrap(arr)
+    end
+
+    def github_from_url(url)
+      return {} unless /\Ahttps:\/\/github\.com\/(.+)(?:\/)?(.+)?(?:\/tree\/)?(.*)\z/.match(url)
+      words = URI.parse(url).path[1..-1].split('/')
+
+      { owner: words[0],
+        repo: words[1],
+        release: words[3] }.compact
+    end
+
+    def github_repo_from_url(url)
+      github_from_url(url).fetch(:repo, nil)
+    end
+
+    def github_release_from_url(url)
+      github_from_url(url).fetch(:release, nil)
+    end
+
+    def github_owner_from_url(url)
+      github_from_url(url).fetch(:owner, nil)
+    end
+
+    def github_as_owner_url(url)
+      github_hash = github_from_url(url)
+      "https://github.com/#{github_hash[:owner]}" if github_hash[:owner].present?
+    end
+
+    def github_as_repo_url(url)
+      github_hash = github_from_url(url)
+      "https://github.com/#{github_hash[:owner]}/#{github_hash[:repo]}" if github_hash[:repo].present?
+    end
+
+    def github_as_release_url(url)
+      github_hash = github_from_url(url)
+      "https://github.com/#{github_hash[:owner]}/#{github_hash[:repo]}/tree/#{github_hash[:release]}" if github_hash[:release].present?
+    end
+
+    def github_as_codemeta_url(url)
+      github_hash = github_from_url(url)
+      "https://raw.githubusercontent.com/#{github_hash[:owner]}/#{github_hash[:repo]}/master/codemeta.json" if github_hash[:owner].present?
     end
   end
 end

data/lib/bolognese/version.rb

@@ -1,3 +1,3 @@
 module Bolognese
-  VERSION = "0.7"
+  VERSION = "0.7.1"
 end

data/spec/author_utils_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Bolognese::Crossref, vcr: true do
+  let(:id) { "https://doi.org/10.1371/journal.pone.0000030" }
+
+  subject { Bolognese::Crossref.new(id: id) }
+
+  context "authors_as_string" do
+    let(:author_with_organization) { [{"@type"=>"person",
+                                       "@id"=>"http://orcid.org/0000-0003-0077-4738",
+                                       "name"=>"Matt Jones"},
+                                      {"@type"=>"person",
+                                       "@id"=>"http://orcid.org/0000-0002-2192-403X",
+                                       "name"=>"Peter Slaughter"},
+                                      {"@type"=>"organization",
+                                       "@id"=>"http://orcid.org/0000-0002-3957-2474",
+                                       "name"=>"University of California, Santa Barbara"}] }
+
+    it "author" do
+      response = subject.authors_as_string(subject.author)
+      expect(response).to eq("Ralser, Markus and Heeren, Gino and Breitenbach, Michael and Lehrach, Hans and Krobitsch, Sylvia")
+    end
+
+    it "single author" do
+      response = subject.authors_as_string(subject.author.first)
+      expect(response).to eq("Ralser, Markus")
+    end
+
+    it "no author" do
+      response = subject.authors_as_string(nil)
+      expect(response).to be_nil
+    end
+
+    it "with organization" do
+      response = subject.authors_as_string(author_with_organization)
+      expect(response).to eq("Matt Jones and Peter Slaughter and {University of California, Santa Barbara}")
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -158,6 +158,29 @@ describe Bolognese::CLI do
       end
     end
 
+    context "codemeta" do
+      let(:file) { fixture_path + "codemeta.json" }
+
+      it 'default' do
+        expect { subject.convert file }.to output(/datePublished/).to_stdout
+      end
+
+      it 'to schema_org' do
+        subject.options = { to: "schema_org" }
+        expect { subject.convert file }.to output(/datePublished/).to_stdout
+      end
+
+      it 'to datacite' do
+        subject.options = { to: "datacite" }
+        expect { subject.convert file }.to output(/http:\/\/datacite.org\/schema\/kernel-4/).to_stdout
+      end
+
+      it 'to bibtex' do
+        subject.options = { to: "bibtex" }
+        expect { subject.convert file }.to output(/@misc{https:\/\/doi.org\/10.5063\/f1m61h5x/).to_stdout
+      end
+    end
+
     # context "unsupported format" do
     #   let(:file) { fixture_path + "crossref.xxx" }
     #

data/spec/codemeta_spec.rb

@@ -1,48 +1,54 @@
 require 'spec_helper'
 
 describe Bolognese::Codemeta, vcr: true do
-  # let(:id) { "https://blog.datacite.org/eating-your-own-dog-food" }
   let(:fixture_path) { "spec/fixtures/" }
-  #
-  # subject { Bolognese::SchemaOrg.new(id: id) }
+  let(:id) { "https://github.com/datacite/maremma" }
 
-  # context "get metadata" do
-  #   it "BlogPosting" do
-  #     expect(subject.id).to eq("https://doi.org/10.5438/4k3m-nyvg")
-  #     expect(subject.url).to eq("https://blog.datacite.org/eating-your-own-dog-food")
-  #     expect(subject.type).to eq("BlogPosting")
-  #     expect(subject.author).to eq([{"@type"=>"Person", "@id"=>"http://orcid.org/0000-0003-1419-2405", "givenName"=>"Martin", "familyName"=>"Fenner"}])
-  #     expect(subject.name).to eq("Eating your own Dog Food")
-  #     expect(subject.alternate_name).to eq("MS-49-3632-5083")
-  #     expect(subject.description).to start_with("Eating your own dog food")
-  #     expect(subject.keywords).to eq("datacite, doi, metadata, featured")
-  #     expect(subject.date_published).to eq("2016-12-20")
-  #     expect(subject.date_modified).to eq("2016-12-20")
-  #     expect(subject.is_part_of).to eq("@type"=>"Blog", "@id"=>"https://doi.org/10.5438/0000-00ss", "name"=>"DataCite Blog")
-  #     expect(subject.citation).to eq([{"@type"=>"CreativeWork", "@id"=>"https://doi.org/10.5438/0012"},
-  #                                     {"@type"=>"CreativeWork", "@id"=>"https://doi.org/10.5438/55e5-t5c0"}])
-  #     expect(subject.publisher).to eq("@type"=>"Organization", "name"=>"DataCite")
-  #   end
-  #
-  #   it "BlogPosting schema.org JSON" do
-  #     json = JSON.parse(subject.as_schema_org)
-  #     expect(json["@id"]).to eq("https://doi.org/10.5438/4k3m-nyvg")
-  #   end
-  #
-  #   it "not found error" do
-  #     id = "https://doi.org/10.5438/4K3M-NYVGx"
-  #     subject = Bolognese::SchemaOrg.new(id: id)
-  #     expect(subject.id).to be_nil
-  #     expect(subject.exists?).to be false
-  #   end
-  # end
+  subject { Bolognese::Codemeta.new(id: id) }
+
+  context "get metadata" do
+    it "maremma" do
+      expect(subject.id).to eq("https://doi.org/10.5438/qeg0-3gm3")
+      expect(subject.url).to eq("https://github.com/datacite/maremma")
+      expect(subject.type).to eq("SoftwareSourceCode")
+      expect(subject.author).to eq("@id"=>"http://orcid.org/0000-0003-0077-4738", "@type"=>"person", "name"=>"Martin Fenner")
+      expect(subject.name).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(subject.description).to start_with("Simplifies network calls")
+      expect(subject.keywords).to eq("faraday, excon, net/http")
+      expect(subject.date_created).to eq("2015-11-28")
+      expect(subject.date_published).to eq("2017-02-24")
+      expect(subject.date_modified).to eq("2017-02-24")
+      expect(subject.publisher).to eq("@type"=>"Organization", "name"=>"DataCite")
+    end
+
+    it "maremma schema.org JSON" do
+      json = JSON.parse(subject.as_schema_org)
+      expect(json["@id"]).to eq("https://doi.org/10.5438/qeg0-3gm3")
+      expect(json["name"]).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(json["author"]).to eq("@type"=>"person", "@id"=>"http://orcid.org/0000-0003-0077-4738", "name"=>"Martin Fenner")
+    end
+
+    it "no codemeta.json" do
+      id = "https://github.com/datacite/homepage"
+      subject = Bolognese::Codemeta.new(id: id)
+      expect(subject.id).to be_nil
+      expect(subject.exists?).to be false
+    end
+
+    it "not found error" do
+      id = "https://github.com/datacite/x"
+      subject = Bolognese::Codemeta.new(id: id)
+      expect(subject.id).to be_nil
+      expect(subject.exists?).to be false
+    end
+  end
 
   context "get metadata as string" do
     let(:string) { IO.read(fixture_path + 'codemeta.json') }
 
     subject { Bolognese::Codemeta.new(string: string) }
 
-    it "SoftwareSourceCode" do
+    it "rdataone" do
       expect(subject.id).to eq("https://doi.org/10.5063/f1m61h5x")
       expect(subject.url).to eq("https://github.com/DataONEorg/rdataone")
       expect(subject.type).to eq("SoftwareSourceCode")
@@ -53,7 +59,6 @@ describe Bolognese::Codemeta, vcr: true do
                                      "@id"=>"http://orcid.org/0000-0002-2192-403X",
                                      "name"=>"Peter Slaughter"},
                                     {"@type"=>"organization",
-                                     "@id"=>"http://orcid.org/0000-0002-3957-2474",
                                      "name"=>"University of California, Santa Barbara"}])
       expect(subject.name).to eq("R Interface to the DataONE REST API")
       expect(subject.description).to start_with("Provides read and write access to data and metadata")
@@ -64,18 +69,93 @@ describe Bolognese::Codemeta, vcr: true do
       expect(subject.date_modified).to eq("2016-05-27")
       expect(subject.publisher).to eq("@type"=>"Organization", "name"=>"https://cran.r-project.org")
     end
+
+    it "maremma" do
+      string = IO.read(fixture_path + 'maremma/codemeta.json')
+      subject = Bolognese::Codemeta.new(string: string)
+      expect(subject.id).to eq("https://doi.org/10.5438/qeg0-3gm3")
+      expect(subject.url).to eq("https://github.com/datacite/maremma")
+      expect(subject.type).to eq("SoftwareSourceCode")
+      expect(subject.author).to eq("@id"=>"http://orcid.org/0000-0003-0077-4738", "@type"=>"person", "name"=>"Martin Fenner")
+      expect(subject.name).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(subject.description).to start_with("Simplifies network calls")
+      expect(subject.keywords).to eq("faraday, excon, net/http")
+      expect(subject.date_created).to eq("2015-11-28")
+      expect(subject.date_published).to eq("2017-02-24")
+      expect(subject.date_modified).to eq("2017-02-24")
+      expect(subject.publisher).to eq("@type"=>"Organization", "name"=>"DataCite")
+    end
   end
 
   context "get metadata as datacite xml" do
-    let(:string) { IO.read(fixture_path + 'codemeta.json') }
-
-    subject { Bolognese::Codemeta.new(string: string) }
-
-    it "SoftwareSourceCode" do
+    it "rdataone" do
+      string = IO.read(fixture_path + 'codemeta.json')
+      subject = Bolognese::Codemeta.new(string: string)
       expect(subject.validation_errors).to be_empty
       datacite = Maremma.from_xml(subject.as_datacite).fetch("resource", {})
       expect(datacite.dig("titles", "title")).to eq("R Interface to the DataONE REST API")
+      expect(datacite.dig("creators", "creator")).to eq([{"creatorName"=>"Matt Jones",
+                                                          "nameIdentifier"=>
+                                                         {"schemeURI"=>"http://orcid.org/",
+                                                          "nameIdentifierScheme"=>"ORCID",
+                                                          "__content__"=>"http://orcid.org/0000-0003-0077-4738"}},
+                                                         {"creatorName"=>"Peter Slaughter",
+                                                          "nameIdentifier"=>
+                                                         {"schemeURI"=>"http://orcid.org/",
+                                                          "nameIdentifierScheme"=>"ORCID",
+                                                          "__content__"=>"http://orcid.org/0000-0002-2192-403X"}},
+                                                         {"creatorName"=>"University of California, Santa Barbara"}])
       expect(datacite.fetch("version")).to eq("2.0.0")
     end
+
+    it "maremma" do
+      expect(subject.validation_errors).to be_empty
+      datacite = Maremma.from_xml(subject.as_datacite).fetch("resource", {})
+      expect(datacite.dig("titles", "title")).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(datacite.dig("creators", "creator")).to eq("creatorName"=>"Martin Fenner", "nameIdentifier"=>{"schemeURI"=>"http://orcid.org/", "nameIdentifierScheme"=>"ORCID", "__content__"=>"http://orcid.org/0000-0003-0077-4738"})
+    end
+  end
+
+  context "get metadata as schema.org JSON" do
+    it "rdataone" do
+      string = IO.read(fixture_path + 'codemeta.json')
+      subject = Bolognese::Codemeta.new(string: string)
+      json = JSON.parse(subject.as_schema_org)
+      expect(json["@id"]).to eq("https://doi.org/10.5063/f1m61h5x")
+      expect(json["@type"]).to eq("SoftwareSourceCode")
+      expect(json["name"]).to eq("R Interface to the DataONE REST API")
+      expect(json["author"]).to eq([{"@type"=>"person",
+                                     "@id"=>"http://orcid.org/0000-0003-0077-4738",
+                                     "name"=>"Matt Jones"},
+                                    {"@type"=>"person",
+                                     "@id"=>"http://orcid.org/0000-0002-2192-403X",
+                                     "name"=>"Peter Slaughter"},
+                                    {"@type"=>"organization",
+                                     "name"=>"University of California, Santa Barbara"}])
+      expect(json["version"]).to eq("2.0.0")
+    end
+
+    it "maremma" do
+      json = JSON.parse(subject.as_schema_org)
+      expect(json["@id"]).to eq("https://doi.org/10.5438/qeg0-3gm3")
+      expect(json["@type"]).to eq("SoftwareSourceCode")
+      expect(json["name"]).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(json["author"]).to eq("@type"=>"person", "@id"=>"http://orcid.org/0000-0003-0077-4738", "name"=>"Martin Fenner")
+    end
+  end
+
+  context "get metadata as bibtex" do
+    it "maremma" do
+      bibtex = BibTeX.parse(subject.as_bibtex).to_a(quotes: '').first
+      expect(bibtex[:bibtex_type].to_s).to eq("misc")
+      expect(bibtex[:bibtex_key]).to eq("https://doi.org/10.5438/qeg0-3gm3")
+      expect(bibtex[:doi]).to eq("10.5438/qeg0-3gm3")
+      expect(bibtex[:url]).to eq("https://github.com/datacite/maremma")
+      expect(bibtex[:title]).to eq("Maremma: a Ruby library for simplified network calls")
+      expect(bibtex[:author]).to eq("Fenner, Martin")
+      expect(bibtex[:publisher]).to eq("DataCite")
+      expect(bibtex[:keywords]).to eq("faraday, excon, net/http")
+      expect(bibtex[:year]).to eq("2017")
+    end
   end
 end