cirneco 0.9.12 → 0.9.13

data/lib/cirneco/work.rb

@@ -1,217 +1,22 @@
-require 'active_support/all'
-require 'nokogiri'
-
+require 'bolognese'
 require_relative 'api'
 require_relative 'utils'
 require_relative 'base'
 
 module Cirneco
-  class Work
+  class Work < Bolognese::Metadata
     include Cirneco::Base
     include Cirneco::Api
     include Cirneco::Utils
 
-    attr_accessor :doi, :url, :creators, :title, :publisher, :publication_year, :resource_type, :version, :alternate_identifier, :related_identifiers, :rights_list, :descriptions, :contributors, :date_issued, :date_created, :date_updated, :subjects, :media, :username, :password, :validation_errors
-
-    def initialize(metadata, **options)
-      @doi = metadata.fetch("doi", nil)
-      @url = metadata.fetch("url", nil)
-      @creators = metadata.fetch("creators", nil)
-      @title = metadata.fetch("title", nil)
-      @publisher = metadata.fetch("publisher", nil)
-      @publication_year = metadata.fetch("publication_year", nil)
-      @resource_type = metadata.fetch("resource_type", nil)
-      @version = metadata.fetch("version", nil)
-      @rights_list = metadata.fetch("rights_list", nil)
-      @date_issued = metadata.fetch("date_issued", nil)
-      @date_created = metadata.fetch("date_created", nil)
-      @date_updated = metadata.fetch("date_updated", nil)
-      @subjects = metadata.fetch("subjects", nil)
-      @descriptions = metadata.fetch("descriptions", nil)
-      @contributors = metadata.fetch("contributors", nil)
-      @alternate_identifier = metadata.fetch("alternate_identifier", nil)
-      @related_identifiers = metadata.fetch("related_identifiers", nil)
-      @media = metadata.fetch("media", nil)
-
-      @username = options.fetch(:username, nil)
-      @password = options.fetch(:password, nil)
-    end
-
-    SCHEMA = File.expand_path("../../../resources/kernel-4.0/metadata.xsd", __FILE__)
-
-    def data
-      Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
-        xml.resource(root_attributes) do
-          insert_work(xml)
-        end
-      end.to_xml
-    end
+    attr_reader :media, :username, :password
 
-    def insert_work(xml)
-      insert_identifier(xml)
-      insert_creators(xml)
-      insert_titles(xml)
-      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_related_identifiers(xml)
-      insert_version(xml)
-      insert_rights_list(xml)
-      insert_descriptions(xml)
-    end
-
-    def insert_identifier(xml)
-      xml.identifier(doi, 'identifierType' => "DOI")
-    end
-
-    def insert_creators(xml)
-      xml.creators do
-        Array(creators).each do |creator|
-          xml.creator do
-            insert_person(xml, creator, "creator")
-          end
-        end
-      end
-    end
-
-    def insert_contributors(xml)
-      return xml unless contributors.present?
-
-      xml.contributors do
-        contributors.each do |contributor|
-          xml.contributor("contributorType" => contributor[:contributor_type]) do
-            insert_person(xml, contributor, "contributor")
-          end
-        end
-      end
-    end
-
-    def insert_person(xml, person, type)
-      person_name = [person[:family_name], person[:given_name], person[:literal]].compact.join(", ")
-
-      xml.send(:'creatorName', person_name) if type == "creator"
-      xml.send(:'contributorName', person_name) if type == "contributor"
-      xml.send(:'givenName', person[:given_name]) if person[:given_name].present?
-      xml.send(:'familyName', person[:family_name]) if person[:family_name].present?
-      xml.nameIdentifier(person[:orcid], 'schemeURI' => 'http://orcid.org/', 'nameIdentifierScheme' => 'ORCID') if person[:orcid].present?
-    end
-
-    def insert_titles(xml)
-      xml.titles do
-        insert_title(xml)
-      end
-    end
-
-    def insert_title(xml)
-      xml.title(title)
-    end
-
-    def insert_publisher(xml)
-      xml.publisher(publisher)
-    end
-
-    def insert_publication_year(xml)
-      xml.publicationYear(publication_year)
-    end
-
-    def insert_resource_type(xml)
-      return xml unless resource_type.present?
-
-      xml.resourceType(resource_type[:value], 'resourceTypeGeneral' => resource_type[:resource_type_general])
-    end
-
-    def insert_alternate_identifiers(xml)
-      return xml unless alternate_identifier.present?
-
-      xml.alternateIdentifiers do
-        xml.alternateIdentifier(alternate_identifier, 'alternateIdentifierType' => "Local accession number")
-      end
-    end
-
-    def insert_dates(xml)
-      xml.dates do
-        insert_date(xml, date_created, 'Created') if date_created.present?
-        insert_date(xml, date_issued, 'Issued') if date_issued.present?
-        insert_date(xml, date_updated, 'Updated') if date_updated.present?
-      end
-    end
-
-    def insert_date(xml, date, date_type)
-      xml.date(date, 'dateType' => date_type)
-    end
-
-    def insert_subjects(xml)
-      return xml unless subjects.present?
-
-      xml.subjects do
-        subjects.each do |subject|
-          xml.subject(subject)
-        end
-      end
-    end
-
-    def insert_version(xml)
-      return xml unless version.present?
-
-      xml.version(version)
-    end
-
-    def insert_related_identifiers(xml)
-      return xml unless related_identifiers.present?
-
-      xml.relatedIdentifiers do
-        related_identifiers.each do |related_identifier|
-          xml.relatedIdentifier(related_identifier[:value], 'relatedIdentifierType' => related_identifier[:related_identifier_type], 'relationType' => related_identifier[:relation_type])
-        end
-      end
-    end
-
-    def insert_rights_list(xml)
-      return xml unless rights_list.present?
-
-      xml.rightsList do
-        rights_list.each do |rights|
-          xml.rights(rights[:value], 'rightsURI' => rights[:rights_uri])
-        end
-      end
-    end
-
-    def insert_descriptions(xml)
-      return xml unless descriptions.present?
-
-      xml.descriptions do
-        descriptions.each do |description|
-          xml.description(description[:value], 'descriptionType' => description[:description_type])
-        end
-      end
-    end
-
-    def without_control(s)
-      r = ''
-      s.each_codepoint do |c|
-        if c >= 32
-          r << c
-        end
-      end
-      r
-    end
-
-    def root_attributes
-      { :'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
-        :'xsi:schemaLocation' => 'http://datacite.org/schema/kernel-4 http://schema.datacite.org/meta/kernel-4/metadata.xsd',
-        :'xmlns' => 'http://datacite.org/schema/kernel-4' }
-    end
-
-    def schema
-      Nokogiri::XML::Schema(open(SCHEMA))
-    end
+    def initialize(input: nil, from: nil, format: nil, **options)
+      @media = options[:media]
+      @username = options[:username]
+      @password = options[:password]
 
-    def validation_errors
-      @validation_errors ||= OpenStruct.new(body: { "errors" => schema.validate(Nokogiri::XML(data)).map { |error| { "title" => error.to_s } } })
+      return super(input: input, from: from, doi: options[:doi])
     end
   end
 end

data/spec/api_spec.rb

@@ -1,20 +1,7 @@
 require 'spec_helper'
 
 describe Cirneco::Work, vcr: true, :order => :defined do
-  let(:doi) { "10.5072/0000-03VC" }
-  let(:url) { "http://www.datacite.org" }
-  let(:creators) { [{ given_name: "Elizabeth", family_name: "Miller", orcid: "0000-0001-5000-0007", affiliation: "DataCite" }] }
-  let(:title) { "Full DataCite XML Example" }
-  let(:publisher) { "DataCite" }
-  let(:publication_year) { 2014 }
-  let(:resource_type) { { value: "XML", resource_type_general: "Software" } }
-  let(:metadata) { { "doi" => doi,
-                     "url" => url,
-                     "creators" => creators,
-                     "title" => title,
-                     "publisher" => publisher,
-                     "publication_year" => publication_year,
-                     "resource_type" => resource_type } }
+  let(:input) { "https://blog.datacite.org/eating-your-own-dog-food/" }
   let(:media) { [{ mime_type: "application/pdf", url:"http://www.datacite.org/cirneco-test.pdf" }]}
   let(:username) { ENV['MDS_USERNAME'] }
   let(:password) { ENV['MDS_PASSWORD'] }
@@ -22,7 +9,7 @@ describe Cirneco::Work, vcr: true, :order => :defined do
   let(:fixture_path) { "spec/fixtures/" }
   let(:samples_path) { "resources/kernel-4.0/samples/" }
 
-  subject { Cirneco::Work.new(metadata,
+  subject { Cirneco::Work.new(input: input,
                               media: media,
                               username: username,
                               password: password) }
@@ -30,23 +17,23 @@ describe Cirneco::Work, vcr: true, :order => :defined do
   describe "Metadata API" do
     context "post" do
       it 'should post metadata' do
-        response = subject.post_metadata(subject.data, options)
-        expect(response.body["data"]).to eq("OK (10.5072/0000-03VC)")
+        response = subject.post_metadata(subject.datacite, options)
+        expect(response.body["data"]).to eq("OK (10.5438/4k3m-nyvg)")
         expect(response.status).to eq(201)
-        expect(response.headers["Location"]).to eq("http://mds-sandbox.datacite.org/metadata/10.5072/0000-03VC")
+        expect(response.headers["Location"]).to eq("http://mds.test.datacite.org/metadata/10.5438/4k3m-nyvg")
       end
     end
 
     context "get" do
       it 'should get metadata' do
-        response = subject.get_metadata(doi, options)
-        expect(response.body["data"]).to eq(subject.data)
+        response = subject.get_metadata(subject.doi, options)
+        expect(response.body["data"]).to eq(subject.datacite)
       end
     end
 
     context "delete" do
       it 'should delete metadata' do
-        response = subject.delete_metadata(doi, options)
+        response = subject.delete_metadata(subject.doi, options)
         expect(response.body["data"]).to eq("OK")
         expect(response.status).to eq(200)
       end
@@ -56,7 +43,8 @@ describe Cirneco::Work, vcr: true, :order => :defined do
   describe "DOI API" do
     describe "put" do
       it 'should put doi' do
-        response = subject.put_doi(doi, options.merge(url: url))
+        url = "http://www.datacite.org"
+        response = subject.put_doi(subject.doi, options.merge(url: url))
         expect(response.body["data"]).to eq("OK")
         expect(response.status).to eq(201)
       end
@@ -66,23 +54,23 @@ describe Cirneco::Work, vcr: true, :order => :defined do
       it 'should get all dois' do
         response = subject.get_dois(options)
         dois = response.body["data"]
-        expect(dois.length).to eq(516)
+        expect(dois.length).to eq(518)
         expect(dois.first).to eq("10.23725/0000-03VC")
       end
 
       it 'should get doi' do
-        response = subject.get_doi(doi, options)
+        response = subject.get_doi(subject.doi, options)
         expect(response.body["data"]).to eq("http://www.datacite.org")
       end
 
       it 'should get doi not found' do
-        response = subject.get_doi("10.5072/0000-03V", options)
+        response = subject.get_doi("10.5438/0000-03V", options)
         expect(response.status).to eq(404)
       end
 
       it 'username missing' do
         options = { username: username, sandbox: true }
-        response = subject.get_doi(doi, options)
+        response = subject.get_doi(subject.doi, options)
         expect(response.body).to eq("errors"=>[{"title"=>"Username or password missing"}])
       end
     end
@@ -91,7 +79,7 @@ describe Cirneco::Work, vcr: true, :order => :defined do
   describe "Media API" do
     describe "post" do
       it 'should post media' do
-        response = subject.post_media(doi, options.merge(media: media))
+        response = subject.post_media(subject.doi, options.merge(media: media))
         expect(response.body["data"]).to eq("OK")
         expect(response.status).to eq(200)
       end
@@ -99,7 +87,7 @@ describe Cirneco::Work, vcr: true, :order => :defined do
 
     describe "get" do
       it 'should get media' do
-        response = subject.get_media(doi, options)
+        response = subject.get_media(subject.doi, options)
         media = response.body["data"]
         expect(media.length).to eq(1)
         expect(media.first).to eq(:mime_type=>"application/pdf", :url=>"http://www.datacite.org/cirneco-test.pdf")

data/spec/doi_spec.rb

@@ -8,7 +8,7 @@ describe Cirneco::Doi do
 
   let(:number) { 123 }
   let(:prefix) { ENV['PREFIX'] }
-  let(:doi) { "10.5072/0000-03VC" }
+  let(:doi) { "10.5438/0000-03VC" }
   let(:url) { "http://www.datacite.org" }
   let(:filename) { 'cool-dois/index.html' }
   let(:filepath) { fixture_path + filename }
@@ -64,7 +64,7 @@ describe Cirneco::Doi do
   context "base32" do
     it 'generates a doi' do
       subject.options = { number: number, prefix: prefix }
-      expect { subject.generate }.to output("10.5072/0000-03VC\n").to_stdout
+      expect { subject.generate }.to output("10.5438/0000-03VC\n").to_stdout
     end
 
     it 'requires a prefix' do
@@ -89,41 +89,41 @@ describe Cirneco::Doi do
   context "mint and hide DOIs", vcr: true, :order => :defined do
     it 'mints a doi' do
       subject.options = mint_options
-      expect { subject.mint filepath }.to output("DOI 10.5072/0000-03VC minted for cool-dois.html.md\n").to_stdout
+      expect { subject.mint filepath }.to output("DOI 10.5438/0000-03VC minted for cool-dois.html.md\n").to_stdout
     end
 
     it 'hides a doi' do
       filename = 'cool-dois-minted/index.html'
       filepath = fixture_path + filename
       subject.options = mint_options.merge(filepath: filepath)
-      expect { subject.hide filepath }.to output("DOI 10.5072/0000-03WD hidden for cool-dois-minted.html.md\n").to_stdout
+      expect { subject.hide filepath }.to output("DOI 10.5438/55E5-T5C0 hidden for cool-dois-minted.html.md\n").to_stdout
     end
 
     it 'mints and hides a doi' do
       subject.options = mint_options
-      expect { subject.mint_and_hide filepath }.to output("DOI 10.5072/0000-03VC minted and hidden for cool-dois.html.md\n").to_stdout
+      expect { subject.mint_and_hide filepath }.to output("DOI 10.5438/0000-03VC minted and hidden for cool-dois.html.md\n").to_stdout
     end
 
     it 'mints dois for list of urls' do
       filepath = fixture_path + 'index.html'
       subject.options = mint_options
-      expect { subject.mint filepath }.to output("DOI 10.5072/0000-03VC minted for cool-dois.html.md\nDOI 10.5072/0000-00SS minted for index.html.erb\n").to_stdout
+      expect { subject.mint filepath }.to output("DOI 10.5438/0000-03VC minted for cool-dois.html.md\nDOI 10.5438/0000-00SS minted for index.html.erb\n").to_stdout
     end
 
     it 'hides dois for list of urls' do
       filepath = fixture_path + 'index.html'
       subject.options = mint_options
-      expect { subject.hide filepath }.to output("No DOI for cool-dois.html.md\nNo DOI for index.html.erb\n").to_stdout
+      expect { subject.hide filepath }.to output("No DOI for cool-dois.html.md\nDOI 10.5438/0000-00SS hidden for index.html.erb\n").to_stdout
     end
 
     it 'mints and hides dois for list of urls' do
       filepath = fixture_path + 'index.html'
       subject.options = mint_options
-      expect { subject.mint_and_hide filepath }.to output("DOI 10.5072/0000-03VC minted and hidden for cool-dois.html.md\nDOI 10.5072/0000-00SS minted and hidden for index.html.erb\n").to_stdout
+      expect { subject.mint_and_hide filepath }.to output("DOI 10.5438/0000-03VC minted and hidden for cool-dois.html.md\nDOI 10.5438/0000-00SS minted and hidden for index.html.erb\n").to_stdout
     end
   end
 
-  context "jats" do
+  context "jats", vcr: true do
     it 'writes jats for list of urls' do
       filepath = fixture_path + 'index.html'
       subject.options = mint_options
@@ -131,5 +131,3 @@ describe Cirneco::Doi do
     end
   end
 end
-
-