marc 0.0.6 → 0.0.7

data/lib/marc/record.rb

@@ -1,123 +1,120 @@
 module MARC
 
-    # A class that represents an individual MARC record. Every record
-    # is made up of a collection of MARC::Field objects. 
-
-    class Record
-        include Enumerable
-
-        # the record fields
-        attr_accessor :fields,
-
-        # the record leader
-        :leader
-
-        def initialize
-            @fields = []
-            # 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
-
-        # add a field to the record
-        #     record.append(MARC::Field.new( '100', '2', '0', ['a', 'Fred']))
-
-        def append(field)
-            @fields.push(field)
-        end
-
-        # each() is here to support iterating and searching since MARC::Record
-        # mixes in Enumberable
-        #
-        # 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)}
-
-        def each
-            for field in @fields
-                yield field
-            end
-        end
-
-        # You can lookup fields using this shorthand:
-        #     title = record['245']
-
-        def [](tag)
-            return self.find {|f| f.tag == tag}
-        end
-
-        # Factory method for creating a MARC::Record from MARC21 in 
-        # transmission format. Really this is just a wrapper around
-        # MARC::MARC21::decode
-        #
-        #     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)
-
-        def self.new_from_marc(raw, params={})
-            return MARC::MARC21.new().decode(raw, params)
-        end
-
-
-        # Handy method for returning a the MARC21 serialization for a 
-        # MARC::Record object. Really this is just a wrapper around
-        # MARC::MARC21::encode
-        # 
-        #     marc = record.to_marc()
-
-        def to_marc 
-            return MARC::MARC21.new().encode(self)
-        end
-
-
-        # Returns a string version of the record, suitable for printing
-
-        def to_s
-            str = "LEADER #{leader}\n"
-            for field in fields:
-                str += field.to_s() + "\n"
-            end
-            return str
-        end
-
-
-        # For testing if two records can be considered equal.
-
-        def ==(other)
-            if @leader != other.leader:
-                return false
-            elsif @fields.length != other.fields.length()
-                return false
-            else 
-                for i in [0..@fields.length()]:
-                    return false if @fields[i] != other.fields[i]
-                end
-            end
-            return true
-        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 
-        end
+  # A class that represents an individual MARC record. Every record
+  # is made up of a collection of MARC::Field objects. 
+
+  class Record
+    include Enumerable
+
+    # the record fields
+    attr_accessor :fields,
+
+    # the record leader
+    :leader
+
+    def initialize
+      @fields = []
+      # 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
+
+    # add a field to the record
+    #   record.append(MARC::Field.new( '100', '2', '0', ['a', 'Fred']))
 
+    def append(field)
+      @fields.push(field)
     end
 
-end
+    # each() is here to support iterating and searching since MARC::Record
+    # mixes in Enumberable
+    #
+    # 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)}
+
+    def each
+      for field in @fields
+        yield field
+      end
+    end
+
+    # You can lookup fields using this shorthand:
+    #   title = record['245']
+
+    def [](tag)
+      return self.find {|f| f.tag == tag}
+    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)
+
+    def self.new_from_marc(raw, params={})
+      return MARC::Reader.decode(raw, params)
+    end
+
+
+    # Handy method for returning a the MARC21 serialization for a 
+    # MARC::Record object. Really this is just a wrapper around
+    # MARC::MARC21::encode
+    # 
+    #   marc = record.to_marc()
+
+    def to_marc 
+      return MARC::Writer.encode(self)
+    end
+
+    # Handy method for returning the MARCXML serialization for a
+    # MARC::Record object.  Really this is just a wrapper around
+    # MARC::MARCXML::encode
+    #
+    #   xml = record.to_xml()
 
+    def to_xml
+      return MARC::MARCXML.new().encode(self)
+    end
+
+    # Returns a string version of the record, suitable for printing
+
+    def to_s
+      str = "LEADER #{leader}\n"
+      for field in fields:
+        str += field.to_s() + "\n"
+      end
+      return str
+    end
+
+
+    # For testing if two records can be considered equal.
+
+    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
+
+    def =~(regex)
+      return self.to_s =~ regex 
+    end
+
+  end
+end

data/lib/marc/subfield.rb

@@ -1,27 +1,26 @@
 module MARC
 
-    class Subfield
-        attr_accessor :code, :value
+  class Subfield
+    attr_accessor :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
-        end
-
-        def ==(other)
-            if @code != other.code
-                return false
-            elsif @value != other.value
-                return false
-            end
-            return true
-        end
+    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
+    end
 
-        def to_s
-            return "$#{code}#{value}"
-        end
+    def ==(other)
+      if @code != other.code
+        return false
+      elsif @value != other.value
+        return false
+      end
+      return true
     end
 
+    def to_s
+      return "$#{code}#{value}"
+    end
+  end
 end

data/lib/marc/writer.rb

@@ -1,36 +1,87 @@
 module MARC
 
-    # A class for writing MARC records as MARC21.
+  # A class for writing MARC records as MARC21.
 
-    class Writer
+  class Writer
 
-        # the constructor which you must pass a file path
-        # or an object that responds to a write message
+    # 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?(file)
-                @fh = file
-            else
-                throw "must pass in file name or handle"
-            end
-        end
+    def initialize(file)
+      if file.class == String
+        @fh = File.new(file,"w")
+      elsif file.respond_to?('write')
+        @fh = file
+      else
+        throw "must pass in file name or handle"
+      end
+    end
 
 
-        # write a record to the file or handle
+    # write a record to the file or handle
+
+    def write(record)
+      @fh.write(MARC::Writer.encode(record))
+    end
+
+
+    # close underlying filehandle
+
+    def close
+      @fh.close
+    end
 
-        def write(record)
-            @fh.write(record.to_marc)
-        end
 
+    # a static method that accepts a MARC::Record object
+    # and returns the record encoded as MARC21 in transmission format
 
-        # close underlying filehandle
+    def self.encode(record)
+      directory = ''
+      fields = ''
+      offset = 0
+      for field in record.fields
 
-        def close
-            @fh.close
+        # encode the field
+        field_data = ''
+        if field.class == MARC::Field 
+          field_data = field.indicator1 + field.indicator2 
+          for s in field.subfields
+            field_data += SUBFIELD_INDICATOR + s.code + s.value
+          end
+        elsif field.class == MARC::Control
+          field_data = field.value
         end
+        field_data += END_OF_FIELD
 
-    end
+        # calculate directory entry for the field
+        field_length = field_data.length()
+        directory += sprintf("%03s%04i%05i", field.tag, field_length, 
+          offset)
+
+        # add field to data for other fields
+        fields += field_data 
+
+        # update offset for next field
+        offset += field_length
+      end
+
+      # determine the base (leader + directory)
+      base = record.leader + directory + END_OF_FIELD
 
+      # determine complete record
+      marc = base + fields + END_OF_RECORD
+
+      # update leader with the byte offest to the end of the directory
+      marc[12..16] = sprintf("%05i", base.length())
+
+      # update the record length
+      marc[0..4] = sprintf("%05i", marc.length())
+      
+      # store updated leader in the record that was passed in
+      record.leader = marc[0..LEADER_LENGTH-1]
+
+      # return encoded marc
+      return marc 
+    end
+  end
 end

data/lib/marc/xmlreader.rb

@@ -0,0 +1,83 @@
+require 'rexml/document'
+require 'rexml/parsers/pullparser'
+
+module MARC
+  
+  class XMLReader
+    include Enumerable
+
+    def initialize(filename)
+      source = File.new(filename)
+      @parser = REXML::Parsers::PullParser.new(source)
+    end
+
+    def each
+      while @parser.has_next?
+        event = @parser.pull
+        # if it's the start of a record element 
+        if event.start_element? and strip_ns(event[0]) == 'record'
+          yield build_record
+        end
+      end
+    end
+
+    private
+
+    def strip_ns(str)
+      return str.sub!(/^.*:/, '')
+    end
+
+    # will accept parse events until a record has been built up
+    #
+    def build_record
+      record = MARC::Record.new
+      data_field = nil
+      control_field = nil
+      subfield = nil
+      text = '' 
+      attrs = nil
+
+      while @parser.has_next?
+        event = @parser.pull
+
+        if event.text?
+          text += event[0].strip
+          next
+        end
+
+        if event.start_element?
+          attrs = event[1]
+          case strip_ns(event[0])
+          when 'controlfield'
+            text = ''
+            control_field = MARC::Control.new(attrs['tag'])
+          when 'datafield'
+            text = ''
+            data_field = MARC::Field.new(attrs['tag'], attrs['ind1'], 
+              attrs['ind2'])
+          when 'subfield'
+            text = ''
+            subfield = MARC::Subfield.new(attrs['code'])
+          end
+        end
+
+        if event.end_element?
+          case strip_ns(event[0])
+          when 'leader'
+            record.leader = text
+          when 'record'
+            return record
+          when 'controlfield'
+            control_field.value = text
+            record.append(control_field)
+          when 'datafield'
+            record.append(data_field)
+          when 'subfield'
+            subfield.value = text
+            data_field.append(subfield)
+          end
+        end
+      end
+    end
+  end
+end