A class that represents an individual MARC record. Every record is made up of a collection of MARC::DataField objects.
MARC::Record mixes in Enumerable to enable access to constituent DataFields. For example, to return a list of all subject DataFields:
record.find_all {|field| field.tag =~ /^6../}
The accessor 'fields' is also an Array of MARC::DataField objects which the client can access or modify if neccesary.
record.fields.delete(field)
Other accessor attribute: 'leader' for record leader as String
A frequent use case is looking up fields in a MARC record by tag, such as 'all the 500 fields'. Certain methods can use a hash keyed by tag name for higher performance lookup by tag. The hash is lazily created on first access – there is some cost of creating the hash, testing shows you get a performance advantage to using the hash-based methods if you are doing at least a dozen lookups.
record.fields("500") # returns an array record.each_by_tag("500") {|field| ... } record.fields(['100', '700']) # can also use an array in both methods record.each_by_tag( 600..699 ) # or a range
MARC::Record is not generally safe for sharing between threads. Even if you think you are just acccessing it read-only, you may accidentally trigger a reindex of the by-tag cache (see above).
However, after you are done constructing a Record, you can mark the `fields` array as immutable. This makes a Record safe for sharing between threads for read-only use, and also helps you avoid accidentally triggering a reindex, as accidental reindexes can harm by-tag lookup performance.
record.fields.freeze
the record leader
# File lib/marc/record.rb, line 103 def initialize @fields = FieldMap.new # leader is 24 bytes @leader = ' ' * 24 # leader defaults: # http://www.loc.gov/marc/bibliographic/ecbdldrd.html @leader[10..11] = '22' @leader[20..23] = '4500' end
# File lib/marc/record.rb, line 274 def self.new_from_hash(h) r = self.new r.leader = h['leader'] if h['fields'] h['fields'].each do |position| position.each_pair do |tag, field| if field.is_a?(Hash) f = MARC::DataField.new(tag, field['ind1'], field['ind2']) field['subfields'].each do | pos | pos.each_pair do |code, value| f.append MARC::Subfield.new(code, value) end end r << f else r << MARC::ControlField.new(tag, field) end end end end return r end
Factory method for creating a MARC::Record from MARC21 in transmission format.
record = MARC::Record.new_from_marc(marc21)
in cases where you might be working with somewhat flawed MARC data you may want to use the :forgiving parameter which will bypass using field byte offsets and simply look for the end of field byte to figure out the end of fields.
record = MARC::Record.new_from_marc(marc21, :forgiving => true)
# File lib/marc/record.rb, line 201 def self.new_from_marc(raw, params={}) return MARC::Reader.decode(raw, params) end
Factory method for creating a new MARC::Record from a marchash object
record = MARC::Record->new_from_marchash(mh)
# File lib/marc/record.rb, line 250 def self.new_from_marchash(mh) r = self.new() r.leader = mh['leader'] mh['fields'].each do |f| if (f.length == 2) r << MARC::ControlField.new(f[0], f[1]) elsif r << MARC::DataField.new(f[0], f[1], f[2], *f[3]) end end return r end
alias to append
# File lib/marc/record.rb, line 123 def <<(field) append(field) end
For testing if two records can be considered equal.
# File lib/marc/record.rb, line 309 def ==(other) return self.to_s == other.to_s end
Handy for using a record in a regex:
if record =~ /Gravity's Rainbow/ then print "Slothrop" end
# File lib/marc/record.rb, line 317 def =~(regex) return self.to_s =~ regex end
You can lookup fields using this shorthand:
title = record['245']
# File lib/marc/record.rb, line 154 def [](tag) return self.find {|f| f.tag == tag} end
add a field to the record
record.append(MARC::DataField.new( '100', '2', '0', ['a', 'Fred']))
# File lib/marc/record.rb, line 116 def append(field) @fields.push(field) @fields.clean = false end
each() is here to support iterating and searching since MARC::Record mixes in Enumerable
iterating through the fields in a record:
record.each { |f| print f }
getting the 245
title = record.find {|f| f.tag == '245'}
getting all subjects
subjects = record.find_all {|f| ('600'..'699') === f.tag}
# File lib/marc/record.rb, line 139 def each for field in @fields yield field end end
A more convenient way to iterate over each field with a given tag.
The filter argument can be a string, array or range.
# File lib/marc/record.rb, line 147 def each_by_tag(filter) @fields.each_by_tag(filter) {|tag| yield tag } end
Provides a backwards compatible means to access the FieldMap. No argument returns the FieldMap array in entirety. Providing a string, array or range of tags will return an array of fields in the order they appear in the record.
# File lib/marc/record.rb, line 162 def fields(filter=nil) unless filter # Since we're returning the FieldMap object, which the caller # may mutate, we precautionarily mark dirty -- unless it's frozen # immutable. @fields.clean = false unless @fields.frozen? return @fields end @fields.reindex unless @fields.clean flds = [] if filter.is_a?(String) && @fields.tags[filter] @fields.tags[filter].each do |idx| flds << @fields[idx] end elsif filter.is_a?(Array) || filter.is_a?(Range) @fields.each_by_tag(filter) do |tag| flds << tag end end flds end
Handy method for returning a hash mapping this records values to the Dublin Core.
dc = record.to_dublin_core() print dc['title']
# File lib/marc/record.rb, line 231 def to_dublin_core return MARC::DublinCore.map(self) end
Returns a (roundtrippable) hash representation for MARC-in-JSON
# File lib/marc/record.rb, line 266 def to_hash record_hash = {'leader'=>@leader, 'fields'=>[]} @fields.each do |field| record_hash['fields'] << field.to_hash end record_hash end
Returns a record in MARC21 transmission format (ANSI Z39.2). Really this is just a wrapper around MARC::MARC21::encode
marc = record.to_marc()
# File lib/marc/record.rb, line 211 def to_marc return MARC::Writer.encode(self) end
Return a marc-hash version of the record
# File lib/marc/record.rb, line 236 def to_marchash return { 'type' => 'marc-hash', 'version' => [MARCHASH_MAJOR_VERSION, MARCHASH_MINOR_VERSION], 'leader' => self.leader, 'fields' => self.map {|f| f.to_marchash} } end
Returns a string version of the record, suitable for printing
# File lib/marc/record.rb, line 298 def to_s str = "LEADER #{leader}\n" for field in fields str += field.to_s() + "\n" end return str end
Handy method for returning the MARCXML serialization for a MARC::Record object. You'll get back a REXML::Document object. Really this is just a wrapper around MARC::XMLWriter.encode
xml_doc = record.to_xml()
# File lib/marc/record.rb, line 221 def to_xml return MARC::XMLWriter.encode(self, :include_namespace => true) end