marc 0.0.6 → 0.0.7

data/lib/marc.rb

@@ -1,3 +1,4 @@
+require 'marc/constants'
 require 'marc/record'
 require 'marc/field'
 require 'marc/control'
@@ -5,4 +6,5 @@ require 'marc/subfield'
 require 'marc/reader'
 require 'marc/writer'
 require 'marc/exception'
-require 'marc/marc21'
+require 'marc/xmlwriter'
+require 'marc/xmlreader'

data/lib/marc/constants.rb

@@ -0,0 +1,14 @@
+module MARC
+
+  # constants used in MARC21 reading/writing
+  LEADER_LENGTH = 24
+  DIRECTORY_ENTRY_LENGTH = 12
+  SUBFIELD_INDICATOR = 0x1F.chr
+  END_OF_FIELD = 0x1E.chr
+  END_OF_RECORD = 0x1D.chr
+
+  # constants used in XML reading/writing 
+  MARC_NS = "http://www.loc.gov/MARC21/slim"
+  MARC_XSD = "http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
+
+end

data/lib/marc/control.rb

@@ -1,36 +1,36 @@
 module MARC
 
-    # A class for representing fields with a tag less than 010.
-    # Ordinary MARC::Field objects are for fields with tags >= 010
-    # which have indicators and subfields.
+  # A class for representing fields with a tag less than 010.
+  # Ordinary MARC::Field objects are for fields with tags >= 010
+  # which have indicators and subfields.
 
-    class Control
+  class Control
 
-        # the tag value (007, 008, etc)
-        attr_accessor :tag
+    # the tag value (007, 008, etc)
+    attr_accessor :tag
 
-        # the value of the control field
-        attr_accessor :value
+    # the value of the control field
+    attr_accessor :value
 
-        # The constructor which must be passed a tag value and 
-        # an optional value for the field.
+    # The constructor which must be passed a tag value and 
+    # an optional value for the field.
 
-        def initialize(tag,value='')
-            @tag = tag
-            @value = value
-            if tag.to_i > 9 
-                raise MARC::Exception.new(), "tag must be greater than 009"
-            end
-        end
-
-        def to_s
-            return "#{tag} #{value}" 
-        end
+    def initialize(tag,value='')
+      @tag = tag
+      @value = value
+      if tag.to_i > 9 
+        raise MARC::Exception.new(), "tag must be greater than 009"
+      end
+    end
 
-        def =~(regex)
-            return self.to_s =~ regex
-        end
+    def to_s
+      return "#{tag} #{value}" 
+    end
 
+    def =~(regex)
+      return self.to_s =~ regex
     end
 
+  end
+
 end

data/lib/marc/exception.rb

@@ -1,9 +1,9 @@
 module MARC
 
-    # basic exception class for exceptions that
-    # can occur during MARC processing.
+  # basic exception class for exceptions that
+  # can occur during MARC processing.
 
-    class Exception < RuntimeError
-    end
+  class Exception < RuntimeError
+  end
 
 end

data/lib/marc/field.rb

@@ -3,141 +3,141 @@ require 'marc/record'
 
 module MARC
 
-    # MARC records are made up of fields, each of which has a tag, 
-    # indicators and subfields. If the tag is between 000-009 it is 
-    # known as a control field, and actually does not have any 
-    # indicators.
-
-    class Field
-        include Enumerable
-
-        # The tag for the field
-        attr_accessor :tag
-
-        # The first indicator
-        attr_accessor :indicator1
-
-        # The second indicator
-        attr_accessor :indicator2
-
-        # A list of MARC::Subfield objects
-        attr_accessor :subfields
-
-
-        # Create a new field with tag, indicators and subfields.
-        # Subfields are passed in as comma separated list of 
-        # MARC::Subfield objects, 
-        # 
-        #     field = MARC::Field.new('245','0','0',
-        #         MARC::Subfield.new('a', 'Consilience :'),
-        #         MARC::Subfield.new('b', 'the unity of knowledge ',
-        #         MARC::Subfield.new('c', 'by Edward O. Wilson.'))
-        # 
-        # or using a shorthand:
-        # 
-        #     field = MARC::Field.new('245','0','0',
-        #         ['a', 'Consilience :'],['b','the unity of knowledge ',
-        #         ['c', 'by Edward O. Wilson.'] )
-
-        def initialize(tag, i1=' ', i2=' ', *subfields)
-            @tag = tag 
-            # can't allow nil to be passed in or else it'll 
-            # screw us up later when we try to encode
-            @indicator1 = i1 == nil ? ' ' : i1
-            @indicator2 = i2 == nil ? ' ' : i2
-            @subfields = []
-
-            # must use MARC::ControlField for tags < 010
-            if @tag.to_i < 10
-                raise MARC::Exception.new(),
-                    "MARC::Field objects can't have tags < 010"
-            end
-
-            # allows MARC::Subfield objects to be passed directly
-            # or a shorthand of ['a','Foo'], ['b','Bar']
-            subfields.each do |subfield| 
-                case subfield
-                when MARC::Subfield
-                    @subfields.push(subfield)
-                when Array
-                    if subfield.length > 2
-                        raise MARC::Exception.new(),
-                            "arrays must only have 2 elements" 
-                    end
-                    @subfields.push(
-                        MARC::Subfield.new(subfield[0],subfield[1]))
-                else 
-                    raise MARC::Exception.new(), 
-                        "invalid subfield type #{subfield.class}"
-                end
-            end
+  # MARC records are made up of fields, each of which has a tag, 
+  # indicators and subfields. If the tag is between 000-009 it is 
+  # known as a control field, and actually does not have any 
+  # indicators.
+
+  class Field
+    include Enumerable
+
+    # The tag for the field
+    attr_accessor :tag
+
+    # The first indicator
+    attr_accessor :indicator1
+
+    # The second indicator
+    attr_accessor :indicator2
+
+    # A list of MARC::Subfield objects
+    attr_accessor :subfields
+
+
+    # Create a new field with tag, indicators and subfields.
+    # Subfields are passed in as comma separated list of 
+    # MARC::Subfield objects, 
+    # 
+    #   field = MARC::Field.new('245','0','0',
+    #     MARC::Subfield.new('a', 'Consilience :'),
+    #     MARC::Subfield.new('b', 'the unity of knowledge ',
+    #     MARC::Subfield.new('c', 'by Edward O. Wilson.'))
+    # 
+    # or using a shorthand:
+    # 
+    #   field = MARC::Field.new('245','0','0',
+    #     ['a', 'Consilience :'],['b','the unity of knowledge ',
+    #     ['c', 'by Edward O. Wilson.'] )
+
+    def initialize(tag, i1=' ', i2=' ', *subfields)
+      @tag = tag 
+      # can't allow nil to be passed in or else it'll 
+      # screw us up later when we try to encode
+      @indicator1 = i1 == nil ? ' ' : i1
+      @indicator2 = i2 == nil ? ' ' : i2
+      @subfields = []
+
+      # must use MARC::ControlField for tags < 010
+      if @tag.to_i < 10
+        raise MARC::Exception.new(),
+          "MARC::Field objects can't have tags < 010"
+      end
+
+      # allows MARC::Subfield objects to be passed directly
+      # or a shorthand of ['a','Foo'], ['b','Bar']
+      subfields.each do |subfield| 
+        case subfield
+        when MARC::Subfield
+          @subfields.push(subfield)
+        when Array
+          if subfield.length > 2
+            raise MARC::Exception.new(),
+              "arrays must only have 2 elements" 
+          end
+          @subfields.push(
+            MARC::Subfield.new(subfield[0],subfield[1]))
+        else 
+          raise MARC::Exception.new(), 
+            "invalid subfield type #{subfield.class}"
         end
+      end
+    end
 
 
-        # Returns a string representation of the field such as:
-        #  245 00 $aConsilience :$bthe unity of knowledge $cby Edward O. Wilson.
+    # Returns a string representation of the field such as:
+    #  245 00 $aConsilience :$bthe unity of knowledge $cby Edward O. Wilson.
 
-        def to_s
-            str = "#{tag} "
-            str += "#{indicator1}#{indicator2} " 
-            @subfields.each { |subfield| str += subfield.to_s }
-            return str
-        end
+    def to_s
+      str = "#{tag} "
+      str += "#{indicator1}#{indicator2} " 
+      @subfields.each { |subfield| str += subfield.to_s }
+      return str
+    end
 
 
-        # Add a subfield (MARC::Subfield) to the field
-        #      field.append(MARC::Subfield('a','Dave Thomas'))
-
-        def append(subfield)
-            @subfields.push(subfield)
-        end
+    # Add a subfield (MARC::Subfield) to the field
+    #    field.append(MARC::Subfield('a','Dave Thomas'))
 
+    def append(subfield)
+      @subfields.push(subfield)
+    end
 
-        # You can iterate through the subfields in a Field:
-        #     field.each {|s| print s}
 
-        def each
-            for subfield in subfields
-                yield subfield
-            end
-        end
+    # You can iterate through the subfields in a Field:
+    #   field.each {|s| print s}
 
+    def each
+      for subfield in subfields
+        yield subfield
+      end
+    end
 
-        # You can lookup subfields with this shorthand. Note it 
-        # will return a string and not a MARC::Subfield object.
-        #     subfield = field['a']
-        
-        def [](code)
-            subfield = self.find {|s| s.code == code}
-            return subfield.value if subfield
-            return
-        end
 
+    # You can lookup subfields with this shorthand. Note it 
+    # will return a string and not a MARC::Subfield object.
+    #   subfield = field['a']
+    
+    def [](code)
+      subfield = self.find {|s| s.code == code}
+      return subfield.value if subfield
+      return
+    end
 
-        # Two fields are equal if their tag, indicators and 
-        # subfields are all equal.
-
-        def ==(other)
-            if @tag != other.tag
-                return false 
-            elsif @indicator1 != other.indicator1
-                return false 
-            elsif @indicator2 != other.indicator2
-                return false 
-            elsif @subfields != other.subfields
-                return false
-            end
-            return true
-        end
 
+    # Two fields are equal if their tag, indicators and 
+    # subfields are all equal.
+
+    def ==(other)
+      if @tag != other.tag
+        return false 
+      elsif @indicator1 != other.indicator1
+        return false 
+      elsif @indicator2 != other.indicator2
+        return false 
+      elsif @subfields != other.subfields
+        return false
+      end
+      return true
+    end
 
-        # To support regex matching with fields
-        #
-        #     if field =~ /Huckleberry/ ...
 
-        def =~(regex)
-            return self.to_s =~ regex
-        end
+    # To support regex matching with fields
+    #
+    #   if field =~ /Huckleberry/ ...
 
+    def =~(regex)
+      return self.to_s =~ regex
     end
+
+  end
 end

data/lib/marc/reader.rb

@@ -1,92 +1,177 @@
 module MARC
 
-    class Reader
-        include Enumerable
-
-        # The constructor which you may pass either a path 
-        #
-        #     reader = MARC::Reader.new('marc.dat')
-        # 
-        # or, if it's more convenient a File object:
-        #
-        #     fh = File.new('marc.dat')
-        #     reader = MARC::Reader.new(fh)
-        #
-        # or really any object that responds to read(n).
-        
-        def initialize(file)
-            if file.class == String:
-                @handle = File.new(file)
-            elsif file.respond_to?("read", 5)
-                @handle = file
-            else
-                throw "must pass in path or file"
-            end
-        end
-
-        # to support iteration:
-        #     for record in reader
-        #         print record
-        #     end
-        #
-        # and even searching:
-        #     record.find { |f| f['245'] =~ /Huckleberry/ }
-
-        def each 
-            # while there is data left in the file
-            while length = @handle.read(5)
-
-                # get the raw MARC21 for a record back from the file
-                # using the record length
-                raw = length + @handle.read(length.to_i-5)
-
-                # create a record from the data and return it
-                record = MARC::Record.new_from_marc(raw)
-                yield record 
-            end
-        end
+  class Reader
+    include Enumerable
+
+    # The constructor which you may pass either a path 
+    #
+    #   reader = MARC::Reader.new('marc.dat')
+    # 
+    # or, if it's more convenient a File object:
+    #
+    #   fh = File.new('marc.dat')
+    #   reader = MARC::Reader.new(fh)
+    #
+    # or really any object that responds to read(n).
+    
+    def initialize(file)
+      if file.class == String:
+        @handle = File.new(file)
+      elsif file.respond_to?("read", 5)
+        @handle = file
+      else
+        throw "must pass in path or file"
+      end
+    end
 
+    # to support iteration:
+    #   for record in reader
+    #     print record
+    #   end
+    #
+    # and even searching:
+    #   record.find { |f| f['245'] =~ /Huckleberry/ }
+
+    def each 
+      # while there is data left in the file
+      while length = @handle.read(5)
+
+        # get the raw MARC21 for a record back from the file
+        # using the record length
+        raw = length + @handle.read(length.to_i-5)
+
+        # create a record from the data and return it
+        #record = MARC::Record.new_from_marc(raw)
+        record = MARC::Reader.decode(raw)
+        yield record 
+      end
     end
 
 
-    # Like Reader ForgivingReader lets you read in a batch of MARC21 records
-    # but it does not use record lengths and field byte offets found in the 
-    # leader and directory. It is not unusual to run across MARC records
-    # which have had their offsets calcualted wrong. In situations like this
-    # the vanilla Reader may fail, and you can try to use ForgivingReader.
-    
-    # The one downside to this is that ForgivingReader will assume that the
-    # order of the fields in the directory is the same as the order of fields
-    # in the field data. Hopefully this will be the case, but it is not 
-    # 100% guranteed which is why the normal behavior of Reader is encouraged.
-
-    class ForgivingReader
-        include Enumerable
-
-        def initialize(file)
-            if file.class == String
-                @handle = File.new(file)
-            elsif file.class == File
-                @handle = file
-            else
-                throw "must pass in path or File object"                
-            end
-        end
+    # A static method for turning raw MARC data in transission
+    # format into a MARC::Record object.
+
+    def self.decode(marc, params={})
+      record = Record.new()
+      record.leader = marc[0..LEADER_LENGTH-1]
+
+      # where the field data starts
+      base_address = record.leader[12..16].to_i
 
+      # get the byte offsets from the record directory
+      directory = marc[LEADER_LENGTH..base_address-1]
 
-        def each 
-            @handle.each_line(MARC::MARC21::END_OF_RECORD) do |raw| 
-                begin
-                    record = MARC::Record.new_from_marc(raw, :forgiving => true)
-                    yield record 
-                rescue StandardError => e
-                    # caught exception just keep barrelling along
-                    # TODO add logging
-                end
-            end
+      throw "invalid directory in record" if directory == nil
+
+      # the number of fields in the record corresponds to 
+      # how many directory entries there are
+      num_fields = directory.length / DIRECTORY_ENTRY_LENGTH
+
+      # when operating in forgiving mode we just split on end of
+      # field instead of using calculated byte offsets from the 
+      # directory
+      all_fields = marc[base_address..-1].split(END_OF_FIELD)
+
+      0.upto(num_fields-1) do |field_num|
+
+        # pull the directory entry for a field out
+        entry_start = field_num * DIRECTORY_ENTRY_LENGTH
+        entry_end = entry_start + DIRECTORY_ENTRY_LENGTH
+        entry = directory[entry_start..entry_end]
+        
+        # extract the tag
+        tag = entry[0..2]
+
+        # get the actual field data
+        # if we were told to be forgiving we just use the
+        # next available chuck of field data that we 
+        # split apart based on the END_OF_FIELD
+        field_data = ''
+        if params[:forgiving]
+          field_data = all_fields.shift()
+
+        # otherwise we actually use the byte offsets in 
+        # directory to figure out what field data to extract
+        else
+          length = entry[3..6].to_i
+          offset = entry[7..11].to_i
+          field_start = base_address + offset
+          field_end = field_start + length - 1
+          field_data = marc[field_start..field_end]
         end
 
+        # remove end of field
+        field_data.delete!(END_OF_FIELD)
+         
+        # add a control field or variable field
+        if tag < '010'
+          record.append(MARC::Control.new(tag,field_data))
+        else
+          field = MARC::Field.new(tag)
+
+          # get all subfields
+          subfields = field_data.split(SUBFIELD_INDICATOR)
+
+          # must have at least 2 elements (indicators, and 1 subfield)
+          # TODO some sort of logging?
+          next if subfields.length() < 2
+
+          # get indicators
+          indicators = subfields.shift()
+          field.indicator1 = indicators[0,1]
+          field.indicator2 = indicators[1,1]
+
+          # add each subfield to the field
+          subfields.each() do |data|
+            subfield = MARC::Subfield.new(data[0,1],data[1..-1])
+            field.append(subfield)
+          end
+
+          # add the field to the record
+          record.append(field)
+        end
+      end
+
+      return record
+    end
+  end
+
+
+  # Like Reader ForgivingReader lets you read in a batch of MARC21 records
+  # but it does not use record lengths and field byte offets found in the 
+  # leader and directory. It is not unusual to run across MARC records
+  # which have had their offsets calcualted wrong. In situations like this
+  # the vanilla Reader may fail, and you can try to use ForgivingReader.
+  
+  # The one downside to this is that ForgivingReader will assume that the
+  # order of the fields in the directory is the same as the order of fields
+  # in the field data. Hopefully this will be the case, but it is not 
+  # 100% guranteed which is why the normal behavior of Reader is encouraged.
+
+  class ForgivingReader
+    include Enumerable
+
+    def initialize(file)
+      if file.class == String
+        @handle = File.new(file)
+      elsif file.class == File
+        @handle = file
+      else
+        throw "must pass in path or File object"        
+      end
     end
 
 
+    def each 
+      @handle.each_line(END_OF_RECORD) do |raw| 
+        begin
+          record = MARC::Reader.decode(raw, :forgiving => true)
+          yield record 
+        rescue StandardError => e
+          # caught exception just keep barrelling along
+          # TODO add logging
+        end
+      end
+    end
+  end
 end