Module: Bolognese::DataciteUtils

Included in:
MetadataUtils
Defined in:
lib/bolognese/datacite_utils.rb

Instance Method Summary collapse

Instance Method Details

#datacite_errors(xml: nil, schema_version: nil) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
 
# File 'lib/bolognese/datacite_utils.rb', line 13

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"
  kernel = schema_version.to_s.split("/").last
  filepath = File.expand_path("../../../resources/#{kernel}/metadata.xsd", __FILE__)
  schema = Nokogiri::XML::Schema(open(filepath))

  schema.validate(Nokogiri::XML(xml, nil, 'UTF-8')).map { |error| error.to_s }.unwrap
rescue Nokogiri::XML::SyntaxError => e
  e.message
end

#datacite_xml ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/bolognese/datacite_utils.rb', line 5

def datacite_xml
  @datacite_xml ||= Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
    xml.resource(root_attributes) do
      insert_work(xml)
    end
  end.to_xml
end

#insert_alternate_identifiers(xml) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
 
# File 'lib/bolognese/datacite_utils.rb', line 111

def insert_alternate_identifiers(xml)
  alternate_identifiers = Array.wrap(identifiers).select { |r| r["identifierType"] != "DOI" }
  return xml unless alternate_identifiers.present?

  xml.alternateIdentifiers do
    Array.wrap(alternate_identifiers).each do |alternate_identifier|
      xml.alternateIdentifier(alternate_identifier["identifier"], 'alternateIdentifierType' => alternate_identifier["identifierType"])
    end
  end
end

#insert_contributors(xml) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/bolognese/datacite_utils.rb', line 56

def insert_contributors(xml)
  return xml unless contributors.present?

  xml.contributors do
    Array.wrap(contributors).each do |con|
      xml.contributor("contributorType" => con["contributorType"] || "Other") do
        insert_person(xml, con, "contributor")
      end
    end
  end
end

#insert_creators(xml) ⇒ Object 



46
47
48
49
50
51
52
53
54
 
# File 'lib/bolognese/datacite_utils.rb', line 46

def insert_creators(xml)
  xml.creators do
    Array.wrap(creators).each do |au|
      xml.creator do
        insert_person(xml, au, "creator")
      end
    end
  end
end

#insert_dates(xml) ⇒ Object 



122
123
124
125
126
127
128
129
130
131
 
# File 'lib/bolognese/datacite_utils.rb', line 122

def insert_dates(xml)
  return xml unless Array.wrap(dates).present?

  xml.dates do
    Array.wrap(dates).each do |date|
      attributes = { 'dateType' => date["dateType"] || "Issued", 'dateInformation' => date["dateInformation"] }.compact
      xml.date(date["date"], attributes)
    end
  end
end

#insert_descriptions(xml) ⇒ Object 



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/bolognese/datacite_utils.rb', line 212

def insert_descriptions(xml)
  return xml unless descriptions.present? || container && container["title"].present?

  xml.descriptions do
    if container && container["title"].present?
      title = [container["title"]]
      volume = "#{container["volume"]}" if container["volume"].present?
      volume += "(#{container["issue"]})" if container["issue"].present?
      pages = [container["firstPage"], container["lastPage"]].compact.join("-") if container["firstPage"].present?
      series_information = [title, volume, pages].compact.join(", ")
      xml.description(series_information, 'descriptionType' => "SeriesInformation")
    end

    Array.wrap(descriptions).each do |description|
      if description.is_a?(Hash)
        d = description
      else
        d = {}
        d["description"] = description
        d["descriptionType"] = "Abstract"
      end

      attributes = { 'xml:lang' => d["lang"], 'descriptionType' => d["descriptionType"] || "Abstract" }.compact

      xml.description(d["description"], attributes)
    end
  end
end

#insert_funding_references(xml) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/bolognese/datacite_utils.rb', line 133

def insert_funding_references(xml)
  return xml unless Array.wrap(funding_references).present?

  xml.fundingReferences do
    Array.wrap(funding_references).each do |funding_reference|
      xml.fundingReference do
        xml.funderName(funding_reference["funderName"])
        xml.funderIdentifier(funding_reference["funderIdentifier"], { "funderIdentifierType" => funding_reference["funderIdentifierType"] }.compact) if funding_reference["funderIdentifier"].present?
        xml.awardNumber(funding_reference["awardNumber"], { "awardURI" => funding_reference["awardUri"] }.compact) if funding_reference["awardNumber"].present? || funding_reference["awardUri"].present?
        xml.awardTitle(funding_reference["awardTitle"]) if funding_reference["awardTitle"].present?
      end
    end
  end
end

#insert_identifier(xml) ⇒ Object 



42
43
44
 
# File 'lib/bolognese/datacite_utils.rb', line 42

def insert_identifier(xml)
  xml.identifier(doi, 'identifierType' => "DOI")
end

#insert_person(xml, person, type) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/bolognese/datacite_utils.rb', line 68

def insert_person(xml, person, type)
  person_name = person["familyName"].present? ? [person["familyName"], person["givenName"]].compact.join(", ") : person["name"]
  attributes = { "nameType" => person["nameType"] }.compact

  xml.send(type + "Name", person_name, attributes)
  xml.givenName(person["givenName"]) if person["givenName"].present?
  xml.familyName(person["familyName"]) if person["familyName"].present?
  Array.wrap(person["nameIdentifiers"]).each do |ni|
    xml.nameIdentifier(ni["nameIdentifier"], 'nameIdentifierScheme' => ni["nameIdentifierScheme"])
  end
end

#insert_publication_year(xml) ⇒ Object 



100
101
102
 
# File 'lib/bolognese/datacite_utils.rb', line 100

def insert_publication_year(xml)
  xml.publicationYear(publication_year)
end

#insert_publisher(xml) ⇒ Object 



96
97
98
 
# File 'lib/bolognese/datacite_utils.rb', line 96

def insert_publisher(xml)
  xml.publisher(publisher || container && container["title"])
end

#insert_related_identifiers(xml) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/bolognese/datacite_utils.rb', line 173

def insert_related_identifiers(xml)
  return xml unless related_identifiers.present?

  xml.relatedIdentifiers do
    related_identifiers.each do |related_identifier|
      attributes = {
        'relatedIdentifierType' => related_identifier["relatedIdentifierType"],
        'relationType' => related_identifier["relationType"],
        'resourceTypeGeneral' => related_identifier["resourceTypeGeneral"] }.compact

      attributes.merge({ 'relatedMetadataScheme' => related_identifier["relatedMetadataSchema"],
        'schemeURI' => related_identifier["schemeUri"],
        'schemeType' => related_identifier["schemeType"]}.compact) if %w(HasMetadata IsMetadataFor).include?(related_identifier["relationType"])

      xml.relatedIdentifier(related_identifier["relatedIdentifier"], attributes)
    end
  end
end

#insert_resource_type(xml) ⇒ Object 



104
105
106
107
108
109
 
# File 'lib/bolognese/datacite_utils.rb', line 104

def insert_resource_type(xml)
  return xml unless types.is_a?(Hash) && (types["schemaOrg"].present? || types["resourceTypeGeneral"])

  xml.resourceType(types["resourceType"] || types["schemaOrg"],
    'resourceTypeGeneral' => types["resourceTypeGeneral"] || Metadata::SO_TO_DC_TRANSLATIONS[types["schemaOrg"]] || "Other")
end

#insert_rights_list(xml) ⇒ Object 



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/bolognese/datacite_utils.rb', line 192

def insert_rights_list(xml)
  return xml unless rights_list.present?

  xml.rightsList do
    Array.wrap(rights_list).each do |rights|
      if rights.is_a?(Hash)
        r = rights
      else
        r = {}
        r["rights"] = rights
        r["rightsUri"] = normalize_id(rights)
      end

      attributes = { 'rightsURI' => r["rightsUri"], 'xml:lang' => r["lang"] }.compact

      xml.rights(r["rights"], attributes)
    end
  end
end

#insert_subjects(xml) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/bolognese/datacite_utils.rb', line 148

def insert_subjects(xml)
  return xml unless subjects.present?

  xml.subjects do
    subjects.each do |subject|
      if subject.is_a?(Hash)
        s = subject
      else
        s = {}
        s["subject"] = subject
      end

      attributes = { "subjectScheme" => s["subjectScheme"], "schemeURI" => s["schemeUri"], "valueURI" => s["valueUri"], "xml:lang" => s["lang"] }.compact

      xml.subject(s["subject"], attributes)
    end
  end
end

#insert_titles(xml) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/bolognese/datacite_utils.rb', line 80

def insert_titles(xml)
  xml.titles do
    Array.wrap(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
end

#insert_version(xml) ⇒ Object 



167
168
169
170
171
 
# File 'lib/bolognese/datacite_utils.rb', line 167

def insert_version(xml)
  return xml unless version.present?

  xml.version(version)
end

#insert_work(xml) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/bolognese/datacite_utils.rb', line 24

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_funding_references(xml)
  insert_dates(xml)
  insert_related_identifiers(xml)
  insert_version(xml)
  insert_rights_list(xml)
  insert_descriptions(xml)
end

#root_attributes ⇒ Object 



241
242
243
244
245
 
# File 'lib/bolognese/datacite_utils.rb', line 241

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