marc 1.1.1 → 1.2.0

data/lib/marc/record.rb

@@ -1,5 +1,4 @@
 module MARC
-
   # The FieldMap is an Array of DataFields and Controlfields.
   # It also contains a Hash representation
   # of the fields for faster lookups (under certain conditions)
@@ -8,7 +7,7 @@ module MARC
     attr_accessor :clean
 
     def initialize
-      @tags  = {}
+      @tags = {}
       @clean = true
     end
 
@@ -16,7 +15,7 @@ module MARC
     # values of the fields Array
     def reindex
       @tags = {}
-      self.each_with_index do |field, i|
+      each_with_index do |field, i|
         @tags[field.tag] ||= []
         @tags[field.tag] << i
       end
@@ -45,7 +44,7 @@ module MARC
       indices.compact!
       return [] if indices.empty?
 
-     # Sort it, so we get the fields back in the order they appear in the record
+      # Sort it, so we get the fields back in the order they appear in the record
       indices.sort!
 
       indices.each do |tag|
@@ -53,13 +52,11 @@ module MARC
       end
     end
 
-
-
     # Freeze for immutability, first reindexing if needed.
     # A frozen FieldMap is safe for concurrent access, and also
     # can more easily avoid accidental reindexing on even read-only use.
     def freeze
-      self.reindex unless @clean
+      reindex unless @clean
       super
     end
   end
@@ -110,19 +107,29 @@ module MARC
     include Enumerable
 
     # the record fields
-    #attr_reader :fields
+    # attr_reader :fields
 
     # the record leader
     attr_accessor :leader
 
     def initialize
-      @fields         = FieldMap.new
+      @fields = FieldMap.new
       # leader is 24 bytes
-      @leader         = ' ' * 24
+      @leader = " " * 24
       # leader defaults:
       # http://www.loc.gov/marc/bibliographic/ecbdldrd.html
-      @leader[10..11] = '22'
-      @leader[20..23] = '4500'
+      @leader[10..11] = "22"
+      @leader[20..23] = "4500"
+    end
+
+    # Returns true if there are no error messages associated with the record
+    def valid?
+      errors.none?
+    end
+
+    # Returns an array of validation errors for all fields in the record
+    def errors
+      @fields.flat_map(&:errors)
     end
 
     # add a field to the record
@@ -152,7 +159,7 @@ module MARC
     #   subjects = record.find_all {|f| ('600'..'699') === f.tag}
 
     def each
-      for field in @fields
+      @fields.each do |field|
         yield field
       end
     end
@@ -167,14 +174,14 @@ module MARC
     #   title = record['245']
 
     def [](tag)
-      return self.find { |f| f.tag == tag }
+      find { |f| f.tag == 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.
-    def fields(filter=nil)
+    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
@@ -198,7 +205,7 @@ module MARC
 
     # Returns an array of all of the tags that appear in the record (not necessarily in the order they appear).
     def tags
-      return @fields.tag_list
+      @fields.tag_list
     end
 
     # Factory method for creating a MARC::Record from MARC21 in
@@ -213,18 +220,17 @@ module MARC
     #
     #  record = MARC::Record.new_from_marc(marc21, :forgiving => true)
 
-    def self.new_from_marc(raw, params={})
-      return MARC::Reader.decode(raw, params)
+    def self.new_from_marc(raw, params = {})
+      MARC::Reader.decode(raw, params)
     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()
 
     def to_marc
-      return MARC::Writer.encode(self)
+      MARC::Writer.encode(self)
     end
 
     # Handy method for returning the MARCXML serialization for a
@@ -232,9 +238,21 @@ module MARC
     # Really this is just a wrapper around MARC::XMLWriter::encode
     #
     #   xml_doc = record.to_xml()
+    def to_xml(include_namespace: true)
+      MARC::XMLWriter.encode(self, include_namespace: include_namespace)
+    end
 
-    def to_xml
-      return MARC::XMLWriter.encode(self, :include_namespace => true)
+    # Create the actual XML string (as opposed to #to_xml which, for historic reasons,
+    # returns an REXML document)
+    # @param [Boolean] fast_but_unsafe Use the fast MARC::UnsafeXMLWriter code
+    # @param [Boolean] include_namespace Include namespaces on the <record> tag?
+    # @return [String] MARC-XML encoding of the record
+    def to_xml_string(fast_but_unsafe: false, include_namespace: true)
+      if fast_but_unsafe
+        MARC::UnsafeXMLWriter.encode(self, include_namespace: include_namespace)
+      else
+        MARC::XMLWriter.encode(self, include_namespace: include_namespace).to_s
+      end
     end
 
     # Handy method for returning a hash mapping this records values
@@ -244,95 +262,87 @@ module MARC
     #   print dc['title']
 
     def to_dublin_core
-      return MARC::DublinCore.map(self)
+      MARC::DublinCore.map(self)
     end
 
     # Return a marc-hash version of the record
     def to_marchash
-      return {
-          'type'    => 'marc-hash',
-          'version' => [MARCHASH_MAJOR_VERSION, MARCHASH_MINOR_VERSION],
-          'leader'  => self.leader,
-          'fields'  => self.map { |f| f.to_marchash }
-      }
+      {"type" => "marc-hash", "version" => [MARCHASH_MAJOR_VERSION, MARCHASH_MINOR_VERSION], "leader" => leader, "fields" => map { |f| f.to_marchash }}
     end
 
-    #to_hash
-
     # Factory method for creating a new MARC::Record from
     # a marchash object
     #
     # record = MARC::Record->new_from_marchash(mh)
 
     def self.new_from_marchash(mh)
-      r        = self.new()
-      r.leader = mh['leader']
-      mh['fields'].each do |f|
-        if (f.length == 2)
+      r = 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
+      r
     end
 
-
     # Returns a (roundtrippable) hash representation for MARC-in-JSON
     def to_hash
-      record_hash = {'leader' => @leader, 'fields' => []}
+      record_hash = {"leader" => @leader, "fields" => []}
       @fields.each do |field|
-        record_hash['fields'] << field.to_hash
+        record_hash["fields"] << field.to_hash
       end
       record_hash
     end
 
+    # Return an actual json-encoded string.
+    def to_json_string
+      MARC::JSONLWriter.encode(self)
+    end
+
     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
+      r = new
+      r.leader = h["leader"]
+      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
-              r << f
-            else
-              r << MARC::ControlField.new(tag, field)
             end
+            r << f
+          else
+            r << MARC::ControlField.new(tag, field)
           end
         end
       end
-      return r
+      r
     end
 
     # Returns a string version of the record, suitable for printing
 
     def to_s
       str = "LEADER #{leader}\n"
-      self.each do |field|
-        str += field.to_s() + "\n"
+      each do |field|
+        str += field.to_s + "\n"
       end
-      return str
+      str
     end
 
-
     # For testing if two records can be considered equal.
 
     def ==(other)
-      return self.to_s == other.to_s
+      to_s == other.to_s
     end
 
-
     # Handy for using a record in a regex:
     #   if record =~ /Gravity's Rainbow/ then print "Slothrop" end
 
     def =~(regex)
-      return self.to_s =~ regex
+      to_s =~ regex
     end
-
   end
 end

data/lib/marc/subfield.rb

@@ -1,31 +1,33 @@
 module MARC
-  
-  # A class that represents an individual  subfield within a DataField. 
-  # Accessor attributes include: code (letter subfield code) and value 
-  # (the content of the subfield). Both can be empty string, but should 
-  # not be set to nil. 
+  # A class that represents an individual  subfield within a DataField.
+  # Accessor attributes include: code (letter subfield code) and value
+  # (the content of the subfield). Both can be empty string, but should
+  # not be set to nil.
 
   class Subfield
     attr_accessor :code, :value
 
-    def initialize(code='' ,value='')
+    def initialize(code = "", value = "")
       # can't allow code of value to be nil
       # or else it'll screw us up later on
-      @code = code == nil ? '' : code
-      @value = value == nil ? '' : value
+      @code = code.nil? ? "" : code
+      @value = value.nil? ? "" : value
     end
 
     def ==(other)
+      if !other.is_a?(Subfield)
+        return false
+      end
       if @code != other.code
         return false
       elsif @value != other.value
         return false
       end
-      return true
+      true
     end
 
     def to_s
-      return "$#{code} #{value} "
+      "$#{code} #{value} "
     end
   end
 end

data/lib/marc/unsafe_xmlwriter.rb

@@ -0,0 +1,93 @@
+require "marc/xmlwriter"
+
+module MARC
+  # UnsafeXMLWriter bypasses real xml handlers like REXML or Nokogiri and just concatenates strings
+  # to produce the XML document. This has no guarantees of validity if the MARC record you're encoding
+  # isn't valid and won't do things like entity expansion, but it does escape using ruby's
+  # String#encode(xml: :text) and it's much, much faster -- 4-5 times faster than using Nokogiri,
+  # and 15-20 times faster than the REXML version.
+  class UnsafeXMLWriter < MARC::XMLWriter
+    XML_HEADER = '<?xml version="1.0" encoding="UTF-8"?>'
+    NS_ATTRS = %(xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/MARC21/slim" xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd")
+
+    NS_COLLECTION = "<collection #{NS_ATTRS}>".freeze
+    COLLECTION = "<collection>".freeze
+    NS_RECORD = "<record #{NS_ATTRS}>".freeze
+    RECORD = "<record>".freeze
+
+    # Write the record to the target
+    # @param [MARC::Record] record
+    def write(record)
+      @fh.write(self.class.encode(record))
+    end
+
+    class << self
+      # Open `collection` tag, w or w/o namespace
+      def open_collection(include_namespace: true)
+        if include_namespace
+          NS_COLLECTION
+        else
+          COLLECTION
+        end
+      end
+
+      def open_record(include_namespace: true)
+        if include_namespace
+          NS_RECORD
+        else
+          RECORD
+        end
+      end
+
+      # Produce an XML string with a single document in a collection
+      # @param [MARC::Record] record
+      # @param [Boolean] include_namespace Whether to namespace the resulting XML
+      def single_record_document(record, include_namespace: true)
+        xml = XML_HEADER.dup
+        xml << open_collection(include_namespace: include_namespace)
+        xml << encode(record, include_namespace: false)
+        xml << "</collection>".freeze
+        xml
+      end
+
+      # Take a record and turn it into a valid MARC-XML string. Note that
+      # this is an XML _snippet_, without an XML header or <collection>
+      # enclosure.
+      # @param [MARC::Record] record The record to encode to XML
+      # @return [String] The XML snippet of the record in MARC-XML
+      def encode(record, include_namespace: true)
+        xml = open_record(include_namespace: include_namespace).dup
+
+        # MARCXML only allows alphanumerics or spaces in the leader
+        lead = fix_leader(record.leader)
+
+        xml << "<leader>" << lead.encode(xml: :text) << "</leader>"
+        record.each do |f|
+          if f.instance_of?(MARC::DataField)
+            xml << open_datafield(f.tag, f.indicator1, f.indicator2)
+            f.each do |sf|
+              xml << open_subfield(sf.code) << sf.value.encode(xml: :text) << "</subfield>"
+            end
+            xml << "</datafield>"
+          elsif f.instance_of?(MARC::ControlField)
+            xml << open_controlfield(f.tag) << f.value.encode(xml: :text) << "</controlfield>"
+          end
+        end
+        xml << "</record>"
+        xml.force_encoding("utf-8")
+      end
+
+      def open_datafield(tag, ind1, ind2)
+        "<datafield tag=\"#{tag}\" ind1=\"#{ind1}\" ind2=\"#{ind2}\">"
+      end
+
+      def open_subfield(code)
+        "<subfield code=\"#{code}\">"
+      end
+
+      def open_controlfield(tag)
+        "<controlfield tag=\"#{tag}\">"
+      end
+    end
+  end
+end

data/lib/marc/version.rb

@@ -1,3 +1,3 @@
 module MARC
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/marc/writer.rb

@@ -1,5 +1,4 @@
 module MARC
-
   # A class for writing MARC records as binary MARC (ISO 2709)
   #
   # == Too-long records
@@ -29,65 +28,65 @@ module MARC
     # the constructor which you must pass a file path
     # or an object that responds to a write message
 
-    def initialize(file)
-      if file.class == String
-        @fh = File.new(file,"w")
-      elsif file.respond_to?('write')
+    def initialize(file, &blk)
+      if file.instance_of?(String)
+        @fh = File.new(file, "w")
+      elsif file.respond_to?(:write)
         @fh = file
       else
         raise ArgumentError, "must pass in file name or handle"
       end
       self.allow_oversized = false
-    end
 
+      if block_given?
+        blk.call(self)
+        self.close
+      end
+    end
 
     # write a record to the file or handle
 
     def write(record)
-      @fh.write(MARC::Writer.encode(record, self.allow_oversized))
+      @fh.write(MARC::Writer.encode(record, allow_oversized))
     end
 
-
     # close underlying filehandle
 
     def close
       @fh.close
     end
 
-
     # a static method that accepts a MARC::Record object
     # and returns the record encoded as MARC21 in transmission format
     #
     # Second arg allow_oversized, default false, set to true
-    # to raise on MARC record that can't fit into ISO 2709. 
+    # to raise on MARC record that can't fit into ISO 2709.
     def self.encode(record, allow_oversized = false)
-      directory = ''
-      fields = ''
+      directory = ""
+      fields = ""
       offset = 0
       record.each do |field|
-
         # encode the field
-        field_data = ''
-        if field.class == MARC::DataField 
+        field_data = ""
+        if field.instance_of?(MARC::DataField)
           warn("Warn:  Missing indicator") unless field.indicator1 && field.indicator2
           field_data = (field.indicator1 || " ") + (field.indicator2 || " ")
-          for s in field.subfields
+          field.subfields.each do |s|
             field_data += SUBFIELD_INDICATOR + s.code + s.value
           end
-        elsif field.class == MARC::ControlField
+        elsif field.instance_of?(MARC::ControlField)
           field_data = field.value
         end
         field_data += END_OF_FIELD
 
         # calculate directory entry for the field
         field_length = (field_data.respond_to?(:bytesize) ?
-          field_data.bytesize() :
-          field_data.length())
+                          field_data.bytesize :
+                          field_data.length)
         directory += sprintf("%03s", field.tag) + format_byte_count(field_length, allow_oversized, 4) + format_byte_count(offset, allow_oversized)
 
-
         # add field to data for other fields
-        fields += field_data 
+        fields += field_data
 
         # update offset for next field
         offset += field_length
@@ -100,19 +99,18 @@ module MARC
       marc = base + fields + END_OF_RECORD
 
       # update leader with the byte offest to the end of the directory
-      bytesize = base.respond_to?(:bytesize) ? base.bytesize() : base.length()
+      bytesize = base.respond_to?(:bytesize) ? base.bytesize() : base.length
       marc[12..16] = format_byte_count(bytesize, allow_oversized)
-      
 
       # update the record length
-      bytesize = marc.respond_to?(:bytesize) ? marc.bytesize() : marc.length()
-      marc[0..4] = format_byte_count(bytesize, allow_oversized)      
+      bytesize = marc.respond_to?(:bytesize) ? marc.bytesize() : marc.length
+      marc[0..4] = format_byte_count(bytesize, allow_oversized)
 
       # store updated leader in the record that was passed in
-      record.leader = marc[0..LEADER_LENGTH-1]
+      record.leader = marc[0..LEADER_LENGTH - 1]
 
       # return encoded marc
-      return marc
+      marc
     end
 
     # Formats numbers for insertion into marc binary slots.
@@ -123,7 +121,7 @@ module MARC
     #
     # first arg is number, second is boolean whether to allow oversized,
     # third is max digits (default 5)
-    def self.format_byte_count(number, allow_oversized, num_digits=5)
+    def self.format_byte_count(number, allow_oversized, num_digits = 5)
       formatted = sprintf("%0#{num_digits}i", number)
       if formatted.length > num_digits
         # uh, oh, we've exceeded our max. Either zero out
@@ -134,8 +132,7 @@ module MARC
           raise MARC::Exception.new("Can't write MARC record in binary format, as a length/offset value of #{number} is too long for a #{num_digits}-byte slot.")
         end
       end
-      return formatted
+      formatted
     end
-
   end
 end