Class: Hydra::Works::Characterization::FitsDocument

Inherits:
Object
  • Object
show all
Defined in:
lib/hydra/works/characterization/fits_document.rb

Constant Summary collapse

PROXIED_TERMS = 
%i(
  fits_version format_label file_mime_type exif_tool_version file_size
  date_modified filename original_checksum date_created rights_basis
  copyright_basis copyright_note well_formed valid filestatus_message
  file_title file_author page_count file_language word_count
  character_count paragraph_count line_count table_count graphics_count
  byte_order compression width video_width video_track_width height
  video_height video_track_height color_space profile_name profile_version
  orientation color_map image_producer capture_device scanning_software
  exif_version gps_timestamp latitude longitude character_set markup_basis
  markup_language audio_duration video_duration bit_depth audio_sample_rate
  video_sample_rate video_audio_sample_rate channels data_format offset
  frame_rate audio_bit_rate video_bit_rate track_frame_rate aspect_ratio
).freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#ng_xml ⇒ Object

Returns the value of attribute ng_xml.



3
4
5
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 3

def ng_xml
  @ng_xml
end

Class Method Details

.terminology ⇒ Object 



24
25
26
27
28
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 24

def self.terminology
  struct = Struct.new(:proxied_term).new
  terminology = Struct.new(:terms)
  terminology.new(PROXIED_TERMS.map { |t| [t, struct] }.to_h)
end

.xml_template ⇒ Object 



353
354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 353

def self.xml_template
  builder = Nokogiri::XML::Builder.new do |xml|
    xml.fits(xmlns: 'http://hul.harvard.edu/ois/xml/ns/fits/fits_output',
             'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
             'xsi:schemaLocation' => "http://hul.harvard.edu/ois/xml/ns/fits/fits_output
             http://hul.harvard.edu/ois/xml/xsd/fits/fits_output.xsd",
             version: '0.6.0', timestamp: '1/25/12 11:04 AM') do
      xml.identification { xml.identity(toolname: 'FITS') }
    end
  end
  builder.doc
end

Instance Method Details

#__cleanup__ ⇒ Object

Cleanup phase; ugly name to avoid collisions. The send construct here is required to fix up values because the setters are not defined, but rather applied with method_missing.



348
349
350
351
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 348

def __cleanup__
  # Add any other scrubbers here; don't return any particular value
  nil
end

#aspect_ratio ⇒ Object

t.aspect_ratio(proxy: [:metadata, :video, :track, :aspect_ratio])



341
342
343
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 341

def aspect_ratio
  ng_xml.css("fits > metadata > video > track[type='video'] > aspectRatio").map(&:text)
end

#audio_bit_rate ⇒ Object

t.audio_bit_rate(proxy: [:metadata, :audio, :bit_rate])



306
307
308
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 306

def audio_bit_rate
  ng_xml.css("fits > metadata > audio > bitRate").map(&:text)
end

#audio_duration ⇒ Object

t.audio_duration(proxy: [:metadata, :audio, :duration])



276
277
278
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 276

def audio_duration
  ng_xml.css("fits > metadata > audio > duration").map(&:text)
end

#audio_sample_rate ⇒ Object

t.audio_sample_rate(proxy: [:metadata, :audio, :sample_rate])



286
287
288
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 286

def audio_sample_rate
  ng_xml.css("fits > metadata > audio > sampleRate").map(&:text)
end

#bit_depth ⇒ Object

t.bit_depth(proxy: [:metadata, :audio, :bit_depth])



281
282
283
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 281

def bit_depth
  ng_xml.css("fits > metadata > audio > bitDepth").map(&:text)
end

#byte_order ⇒ Object

t.byte_order(proxy: [:metadata, :image, :byte_order])



159
160
161
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 159

def byte_order
  ng_xml.css("fits > metadata > image > byteOrder").map(&:text)
end

#capture_device ⇒ Object

t.capture_device(proxy: [:metadata, :image, :capture_device])



231
232
233
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 231

def capture_device
  ng_xml.css("fits > metadata > image > captureDevice").map(&:text)
end

#channels ⇒ Object

t.channels(proxy: [:metadata, :audio, :channels])



291
292
293
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 291

def channels
  ng_xml.css("fits > metadata > audio > channels").map(&:text)
end

#character_count ⇒ Object

t.character_count(proxy: [:metadata, :document, :character_count])



134
135
136
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 134

def character_count
  ng_xml.css("fits > metadata > document > characterCount").map(&:text)
end

#character_set ⇒ Object

t.character_set(proxy: [:metadata, :text, :character_set])



261
262
263
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 261

def character_set
  ng_xml.css("fits > metadata > text > charset").map(&:text)
end

#color_map ⇒ Object

t.color_map(proxy: [:metadata, :image, :color_map])



221
222
223
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 221

def color_map
  ng_xml.css("fits > metadata > image > colorMap").map(&:text)
end

#color_space ⇒ Object

t.color_space(proxy: [:metadata, :image, :color_space])



201
202
203
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 201

def color_space
  ng_xml.css("fits > metadata > image > colorSpace").map(&:text)
end

#compression ⇒ Object

t.compression(proxy: [:metadata, :image, :compression])



164
165
166
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 164

def compression
  ng_xml.css("fits > metadata > image > compressionScheme").map(&:text)
end

#copyright_basis ⇒ Object

t.copyright_basis(proxy: [:fileinfo, :copyright_basis])



84
85
86
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 84

def copyright_basis
  ng_xml.css("fits > fileinfo > copyrightBasis").map(&:text)
end

#copyright_note ⇒ Object

t.copyright_basis(proxy: [:fileinfo, :copyright_note])



89
90
91
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 89

def copyright_note
  ng_xml.css("fits > fileinfo > copyrightNote").map(&:text)
end

#data_format ⇒ Object

t.data_format(proxy: [:metadata, :audio, :data_format])



296
297
298
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 296

def data_format
  ng_xml.css("fits > metadata > audio > dataFormatType").map(&:text)
end

#date_created ⇒ Object

t.date_created(proxy: [:fileinfo, :date_created])



74
75
76
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 74

def date_created
  ng_xml.css("fits > fileinfo > created[toolname='Exiftool']").map(&:text)
end

#date_modified ⇒ Object

t.date_modified(proxy: [:fileinfo, :last_modified])



59
60
61
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 59

def date_modified
  ng_xml.css("fits > fileinfo > lastmodified[toolname='Exiftool']").map(&:text)
end

#exif_tool_version ⇒ Object

t.exif_tool_version(proxy: [:identification, :identity, :tool, :exif_tool_version])



49
50
51
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 49

def exif_tool_version
  ng_xml.css("fits > identification > identity > tool[toolname='Exiftool']").map { |n| n['toolversion'] }
end

#exif_version ⇒ Object

t.exif_version(proxy: [:metadata, :image, :exif_version])



241
242
243
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 241

def exif_version
  ng_xml.css("fits > metadata > image > exifVersion[toolname='Exiftool']").map(&:text)
end

#file_author ⇒ Object

t.file_author(proxy: [:metadata, :document, :file_author])



114
115
116
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 114

def file_author
  ng_xml.css("fits > metadata > document > author").map(&:text)
end

#file_language ⇒ Object

t.file_language(proxy: [:metadata, :document, :file_language])



119
120
121
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 119

def file_language
  ng_xml.css("fits > metadata > document > language").map(&:text)
end

#file_mime_type ⇒ Object

Can’t use .mime_type because it’s already defined for this document so method missing won’t work. t.file_mime_type(proxy: [:identification, :identity, :mime_type])



42
43
44
45
46
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 42

def file_mime_type
  # Sometimes, FITS reports the mimetype attribute as a comma-separated string.
  # All terms are arrays and, in this case, there is only one element, so scan the first.
  ng_xml.css("fits > identification > identity").map { |n| n['mimetype'].split(',').first }
end

#file_size ⇒ Object

t.file_size(proxy: [:fileinfo, :file_size])



54
55
56
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 54

def file_size
  ng_xml.css("fits > fileinfo > size").map(&:text)
end

#file_title ⇒ Object

t.file_title(proxy: [:metadata, :document, :file_title])



109
110
111
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 109

def file_title
  ng_xml.css("fits > metadata > document > title").map(&:text)
end

#filename ⇒ Object

t.filename(proxy: [:fileinfo, :filename])



64
65
66
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 64

def filename
  ng_xml.css("fits > fileinfo > filename").map(&:text)
end

#filestatus_message ⇒ Object

t.filestatus_message(proxy: [:filestatus, :status_message])



104
105
106
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 104

def filestatus_message
  ng_xml.css("fits > filestatus > message").map(&:text)
end

#fits_version ⇒ Object

t.fits_version(proxy: [:fits, :fits_v])



31
32
33
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 31

def fits_version
  ng_xml.css("fits").map { |n| n['version'].text }
end

#format_label ⇒ Object

t.format_label(proxy: [:identification, :identity, :format_label])



36
37
38
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 36

def format_label
  ng_xml.css("fits > identification > identity").map { |n| n['format'] }
end

#frame_rate ⇒ Object

t.frame_rate(proxy: [:metadata, :video, :frame_rate])



326
327
328
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 326

def frame_rate
  ng_xml.css("fits > metadata > video > frameRate").map(&:text)
end

#gps_timestamp ⇒ Object

t.gps_timestamp(proxy: [:metadata, :image, :gps_timestamp])



246
247
248
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 246

def gps_timestamp
  ng_xml.css("fits > metadata > image > gpsTimeStamp").map(&:text)
end

#graphics_count ⇒ Object

t.graphics_count(proxy: [:metadata, :document, :graphics_count])



154
155
156
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 154

def graphics_count
  ng_xml.css("fits > metadata > document > graphicsCount").map(&:text)
end

#height ⇒ Object

t.height(proxy: [:metadata, :image, :height])



174
175
176
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 174

def height
  ng_xml.css("fits > metadata > image > imageHeight").map(&:text)
end

#image_producer ⇒ Object

t.image_producer(proxy: [:metadata, :image, :image_producer])



226
227
228
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 226

def image_producer
  ng_xml.css("fits > metadata > image > imageProducer").map(&:text)
end

#latitude ⇒ Object

t.latitude(proxy: [:metadata, :image, :latitude])



251
252
253
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 251

def latitude
  ng_xml.css("fits > metadata > image > gpsDestLatitude").map(&:text)
end

#line_count ⇒ Object

t.line_count(proxy: [:metadata, :document, :line_count])



144
145
146
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 144

def line_count
  ng_xml.css("fits > metadata > document > lineCount").map(&:text)
end

#longitude ⇒ Object

t.longitude(proxy: [:metadata, :image, :longitude])



256
257
258
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 256

def longitude
  ng_xml.css("fits > metadata > image > gpsDestLongitude").map(&:text)
end

#markup_basis ⇒ Object

t.markup_basis(proxy: [:metadata, :text, :markup_basis])



266
267
268
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 266

def markup_basis
  ng_xml.css("fits > metadata > text > markupBasis").map(&:text)
end

#markup_language ⇒ Object

t.markup_language(proxy: [:metadata, :text, :markup_language])



271
272
273
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 271

def markup_language
  ng_xml.css("fits > metadata > text > markupLanguage").map(&:text)
end

#offset ⇒ Object

t.offset(proxy: [:metadata, :audio, :offset])



301
302
303
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 301

def offset
  ng_xml.css("fits > metadata > audio > offset").map(&:text)
end

#orientation ⇒ Object

t.orientation(proxy: [:metadata, :image, :orientation])



216
217
218
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 216

def orientation
  ng_xml.css("fits > metadata > image > orientation").map(&:text)
end

#original_checksum ⇒ Object

t.original_checksum(proxy: [:fileinfo, :original_checksum])



69
70
71
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 69

def original_checksum
  ng_xml.css("fits > fileinfo > md5checksum").map(&:text)
end

#page_count ⇒ Object

t.page_count(proxy: [:metadata, :document, :page_count])



124
125
126
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 124

def page_count
  ng_xml.css("fits > metadata > document > pageCount").map(&:text)
end

#paragraph_count ⇒ Object

t.paragraph_count(proxy: [:metadata, :document, :paragraph_count])



139
140
141
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 139

def paragraph_count
  ng_xml.css("fits > metadata > document > paragraphCount").map(&:text)
end

#profile_name ⇒ Object

t.profile_name(proxy: [:metadata, :image, :profile_name])



206
207
208
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 206

def profile_name
  ng_xml.css("fits > metadata > image > iccProfileName").map(&:text)
end

#profile_version ⇒ Object

t.profile_version(proxy: [:metadata, :image, :profile_version])



211
212
213
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 211

def profile_version
  ng_xml.css("fits > metadata > image > iccProfileVersion").map(&:text)
end

#proxied_term_hash ⇒ Object 



20
21
22
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 20

def proxied_term_hash
  PROXIED_TERMS.map { |t| [t, send(t)] }.to_h
end

#rights_basis ⇒ Object

t.rights_basis(proxy: [:fileinfo, :rights_basis])



79
80
81
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 79

def rights_basis
  ng_xml.css("fits > fileinfo > rightsBasis").map(&:text)
end

#scanning_software ⇒ Object

t.scanning_software(proxy: [:metadata, :image, :scanning_software])



236
237
238
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 236

def scanning_software
  ng_xml.css("fits > metadata > image > scanningSoftwareName").map(&:text)
end

#table_count ⇒ Object

t.table_count(proxy: [:metadata, :document, :table_count])



149
150
151
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 149

def table_count
  ng_xml.css("fits > metadata > document > tableCount").map(&:text)
end

#track_frame_rate ⇒ Object

t.track_frame_rate(proxy: [:metadata, :video, :track, :frame_rate])



336
337
338
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 336

def track_frame_rate
  ng_xml.css("fits > metadata > video > track[type='video'] > frameRate").map(&:text)
end

#valid ⇒ Object

t.valid(proxy: [:filestatus, :valid])



99
100
101
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 99

def valid
  ng_xml.css("fits > filestatus > valid").map(&:text)
end

#video_audio_sample_rate ⇒ Object

t.video_audio_sample_rate(proxy: [:metadata, :video, :audio_sample_rate])



321
322
323
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 321

def video_audio_sample_rate
  ng_xml.css("fits > metadata > video > audioSampleRate").map(&:text)
end

#video_bit_rate ⇒ Object

t.video_bit_rate(proxy: [:metadata, :video, :bit_rate])



331
332
333
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 331

def video_bit_rate
  ng_xml.css("fits > metadata > video > bitRate").map(&:text)
end

#video_duration ⇒ Object

t.video_duration(proxy: [:metadata, :video, :duration])



311
312
313
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 311

def video_duration
  ng_xml.css("fits > metadata > video > duration").map(&:text)
end

#video_height ⇒ Object

t.video_height(proxy: [:metadata, :video, :height])



184
185
186
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 184

def video_height
  ng_xml.css("fits > metadata > video > imageHeight").map(&:text)
end

#video_sample_rate ⇒ Object

t.video_sample_rate(proxy: [:metadata, :video, :sample_rate])



316
317
318
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 316

def video_sample_rate
  ng_xml.css("fits > metadata > video > sampleRate").map(&:text)
end

#video_track_height ⇒ Object

for fits 1 t.video_track_height(proxy: [:metadata, :video, :track, :height])



196
197
198
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 196

def video_track_height
  ng_xml.css("fits > metadata > video > track[type='video'] > height").map(&:text)
end

#video_track_width ⇒ Object

for fits 1 t.video_track_width(proxy: [:metadata, :video, :track, :width])



190
191
192
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 190

def video_track_width
  ng_xml.css("fits > metadata > video > track[type='video'] > width").map(&:text)
end

#video_width ⇒ Object

t.video_width(proxy: [:metadata, :video, :width])



179
180
181
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 179

def video_width
  ng_xml.css("fits > metadata > video > imageWidth").map(&:text)
end

#well_formed ⇒ Object

t.well_formed(proxy: [:filestatus, :well_formed])



94
95
96
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 94

def well_formed
  ng_xml.css("fits > filestatus > well-formed").map(&:text)
end

#width ⇒ Object

t.width(proxy: [:metadata, :image, :width])



169
170
171
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 169

def width
  ng_xml.css("fits > metadata > image > imageWidth").map(&:text)
end

#word_count ⇒ Object

t.word_count(proxy: [:metadata, :document, :word_count])



129
130
131
 
# File 'lib/hydra/works/characterization/fits_document.rb', line 129

def word_count
  ng_xml.css("fits > metadata > document > wordCount").map(&:text)
end