enhanced_marc 0.1.5

data/lib/enhanced_marc/leftovers.rb

@@ -0,0 +1,122 @@
+    def get_fixed_field_position
+      ff_pos = {
+        'Ctry' => {
+          '008' => {
+            'BKS' => {:start => 15, :len => 3, :def => ' ' },
+            'SER' => {:start => 15, :len => 3, :def => ' ' },
+            'VIS' => {:start => 15, :len => 3, :def => ' ' },
+            'MIX' => {:start => 15, :len => 3, :def => ' ' },
+            'MAP' => {:start => 15, :len => 3, :def => ' ' },
+            'SCO' => {:start => 15, :len => 3, :def => ' ' },
+            'REC' => {:start => 15, :len => 3, :def => ' ' },
+            'COM' => {:start => 15, :len => 3, :def => ' ' }
+          }
+        },
+        'Lang' => {
+          '008' => {
+            'BKS' => {:start => 35, :len => 3, :def => ' ' },
+            'SER' => {:start => 35, :len => 3, :def => ' ' },
+            'VIS' => {:start => 35, :len => 3, :def => ' ' },
+            'MIX' => {:start => 35, :len => 3, :def => ' ' },
+            'MAP' => {:start => 35, :len => 3, :def => ' ' },
+            'SCO' => {:start => 35, :len => 3, :def => ' ' },
+            'REC' => {:start => 35, :len => 3, :def => ' ' },
+            'COM' => {:start => 35, :len => 3, :def => ' ' }
+          }
+        },
+        'MRec' => {
+          '008' => {
+            'BKS' => {:start => 38, :len => 3, :def => ' ' },
+            'SER' => {:start => 38, :len => 3, :def => ' ' },
+            'VIS' => {:start => 38, :len => 3, :def => ' ' },
+            'MIX' => {:start => 38, :len => 3, :def => ' ' },
+            'MAP' => {:start => 38, :len => 3, :def => ' ' },
+            'SCO' => {:start => 38, :len => 3, :def => ' ' },
+            'REC' => {:start => 38, :len => 3, :def => ' ' },
+            'COM' => {:start => 38, :len => 3, :def => ' ' }
+          }
+        },
+        'DtSt' => {
+          '008' => {
+            'BKS' => {:start => 6, :len => 1, :def => ' ' },
+            'SER' => {:start => 6, :len => 1, :def => 'c' },
+            'VIS' => {:start => 6, :len => 1, :def => ' ' },
+            'MIX' => {:start => 6, :len => 1, :def => ' ' },
+            'MAP' => {:start => 6, :len => 1, :def => ' ' },
+            'SCO' => {:start => 6, :len => 1, :def => ' ' },
+            'REC' => {:start => 6, :len => 1, :def => ' ' },
+            'COM' => {:start => 6, :len => 1, :def => ' ' },
+          }
+        },
+        'Type' => {
+          'ldr' => {
+            'BKS' => {:start => 6, :len => 1, :def => 'a' },
+            'SER' => {:start => 6, :len => 1, :def => 'a' },
+            'VIS' => {:start => 6, :len => 1, :def => 'g' },
+            'MIX' => {:start => 6, :len => 1, :def => 'p' },
+            'MAP' => {:start => 6, :len => 1, :def => 'e' },
+            'SCO' => {:start => 6, :len => 1, :def => 'c' },
+            'REC' => {:start => 6, :len => 1, :def => 'i' },
+            'COM' => {:start => 6, :len => 1, :def => 'm' },
+          }
+        },
+        'Ctrl' => {
+          'ldr' => {
+            'BKS' => {:start => 8, :len => 1, :def => ' ' },
+            'SER' => {:start => 8, :len => 1, :def => ' ' },
+            'VIS' => {:start => 8, :len => 1, :def => ' ' },
+            'MIX' => {:start => 8, :len => 1, :def => ' ' },
+            'MAP' => {:start => 8, :len => 1, :def => ' ' },
+            'SCO' => {:start => 8, :len => 1, :def => ' ' },
+            'REC' => {:start => 8, :len => 1, :def => ' ' },
+            'COM' => {:start => 8, :len => 1, :def => ' ' },
+          }
+        },
+        'BLvl' => {
+        	'ldr'=> {
+        		'BKS' => {:start => 7, :len => 1, :def => 'm' },
+        		'SER' => {:start => 7, :len => 1, :def => 's' },
+        		'VIS' => {:start => 7, :len => 1, :def => 'm' },
+        		'MIX' => {:start => 7, :len => 1, :def => 'c' },
+        		'MAP' => {:start => 7, :len => 1, :def => 'm' },
+        		'SCO' => {:start => 7, :len => 1, :def => 'm' },
+        		'REC' => {:start => 7, :len => 1, :def => 'm' },
+        		'COM' => {:start => 7, :len => 1, :def => 'm' },
+        	}
+        },
+        'Desc' => {
+        	'ldr' => {
+            'BKS' => {:start => 18, :len => 1, :def => ' ' },
+            'SER' => {:start => 18, :len => 1, :def => ' ' },
+            'VIS' => {:start => 18, :len => 1, :def => ' ' },
+            'MIX' => {:start => 18, :len => 1, :def => ' ' },
+            'MAP' => {:start => 18, :len => 1, :def => ' ' },
+            'SCO' => {:start => 18, :len => 1, :def => ' ' },
+            'REC' => {:start => 18, :len => 1, :def => ' ' },
+            'COM' => {:start => 18, :len => 1, :def => ' ' },
+        	}
+        },
+        'ELvl' => {
+        	'ldr' => {
+            'BKS' => {:start => 17, :len => 1, :def => ' ' },
+            'SER' => {:start => 17, :len => 1, :def => ' ' },
+            'VIS' => {:start => 17, :len => 1, :def => ' ' },
+            'MIX' => {:start => 17, :len => 1, :def => ' ' },
+            'MAP' => {:start => 17, :len => 1, :def => ' ' },
+            'SCO' => {:start => 17, :len => 1, :def => ' ' },
+            'REC' => {:start => 17, :len => 1, :def => ' ' },
+            'COM' => {:start => 17, :len => 1, :def => ' ' },
+        	}
+        },
+        'TMat' => {
+        	'008' => {
+        		'VIS' => {:start => 33, :len => 1, :def => ' ' },        		
+        	},
+        	'006' => {
+        		'VIS' => {:start => 16, :len => 1, :def => ' ' },
+        	}
+        },
+       }
+
+    
+    end

data/lib/enhanced_marc/map_record.rb

@@ -0,0 +1,38 @@
+module MARC
+
+  # A class that represents an individual MARC record. Every record
+  # is made up of a collection of MARC::Field objects. 
+
+  class MapRecord < Record
+
+    def initialize
+      super
+      @leader[6] = 'e' if @leader[6,1] == ' '
+      @leader[7] = 'm' if @leader[7,1] == ' '    
+      @record_type = 'MAP'  
+      @bibliographic_level = @leader.get_blvl
+      self.extend MapType      
+      self.inspect_fixed_fields      
+    end
+    
+    def is_valid_type?
+      return false unless @leader[6,1].match(/[ef]{1}/)
+      return true
+    end
+    def is_valid_blvl?
+      return true if @leader[7,1].match(/[acdim]{1}/) and @leader[6,1].match('f')
+      return true if @leader[7,1].match(/[abcdims]{1}/) and @leader[6,1].match('e')
+      return false
+    end
+    def self.new_from_record(record)
+      rec = MapRecord.new
+      record.instance_variables.each { | var |
+        rec.instance_variable_set(var, record.instance_variable_get(var))
+      }
+      return Exception.new("Incorrect type declaration in leader") unless rec.is_valid_type?
+      return Exception.new("Incorrect bibliographic declaration in leader") unless rec.is_valid_blvl?
+      return rec
+    end    
+    
+  end
+end

data/lib/enhanced_marc/map_type.rb

@@ -0,0 +1,99 @@
+module MapType
+  include RecordType
+  public :is_govdoc?, :form, :has_index?
+  def cartographic_type(human_readable=false)
+    crtp_map = {'a'=>'Map', 'b'=>'Map series', 'c'=>'Map serial', 'd'=>'Globe', 'e'=>'Atlas',
+      'f'=>'Supplement', 'g'=>'Bound as part of another work', 'u'=>'Unknown', 'z'=>'Other'}
+    human_readable = crtp_map if human_readable
+    return self.field_parser({:match=>'MAP', :start=>25,:end=>1}, {:match=>/[ef]{1}/, :start=>8,:end=>1}, human_readable)               
+  end    
+  
+  def relief(human_readable=false)
+    relief_map = {'a'=>'Contours', 'b'=>'Shading', 'c'=>'Grading and bathymetric tints',
+      'd'=>'Hachures', 'e'=>'Bathymetry, soundings', 'f'=>'Form lines', 'g'=>'Spot heights',
+      'h'=>'Color', 'i'=>'Pictorially', 'j'=>'Land forms', 'k'=>'Bathymetry, isolines', 
+      'm'=>'Rock drawings', 'z'=>'Other'
+      }
+    contents = []
+    if self.record_type == 'MAP'
+      self['008'].value[18,4].split(//).each { | char | 
+        next if char == " "
+        if human_readable
+          contents << relief_map[char]
+        else
+          contents << char
+        end
+      }
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      next unless fxd_fld.value[0,1].match(/[ef]{1}/)     
+      fxd_fld.value[1,4].split(//).each { | char | 
+        next if char == " "
+        if human_readable
+          contents << relief_map[char]
+        else
+          contents << char
+        end
+      }
+    }       
+    return false if contents.empty?
+    return contents        
+  end
+  
+  def projection(human_readable=false)
+    proj_map = {'Azimuthal'=>{'aa'=>'Aitoff','ab'=>'Gnomic','ac'=>"Lambert's equal area",
+                              'ad'=>'Orthographic','ae'=>'Azithumal equidistant', 'af'=>'Stereographic',
+                              'ag'=>'General vertical near-sided','am'=>'Modified stereographic for Alaska',
+                              'an'=>'Chamberlin trimetric','ap'=>'Polar stereographic','au'=>'Unknown','az'=>'Other'},
+                'Cylindrical'=>{'ba'=>'Gall','bb'=>"Goode's homolographic",'bc'=>"Lambert's equal area",
+                                'bd'=>'Mercator','be'=>'Miller','bf'=>'Mollweide','bg'=>'Sinusoidal',
+                                'bh'=>'Transverse Mercator','bi'=>'Gauss-Kruger','bj'=>'Equirectangular',
+                                'bo'=>'Oblique Mercator','br'=>'Robinson','bs'=>'Space oblique Mercator',
+                                'bu'=>'Unknown','bz'=>'Other'
+                                },
+                'Conic'=>{'ca'=>"Alber's equal area",'cb'=>'Bonne','cc'=>"Lambert's",'ce'=>'Equidistant conic',
+                          'cp'=>'Polyconic','cu'=>'Unknown','cz'=>'Other'
+                          },
+                'Other'=>{'da'=>'Armadillo','db'=>'Butterfly','dc'=>'Eckert','dd'=>"Goode's homolosine",
+                          'de'=>"Miller's bipolar oblique conformal conic",'df'=>'Van Der Grinten',
+                          'dg'=>'Dymaxion','dh'=>'Cordiform','dl'=>'Lambert conformal','zz'=>'Other'                          
+                }
+    }
+    if @record_type == "MAP"
+      unless self['008'].value[22,2] == '  '
+        if human_readable
+          proj_map.each_key { | general |
+            next unless proj_map[general].keys.index(self['008'].value[22,2])
+            return [general,proj_map[general][self['008'].value[22,2]]]
+          }
+        else
+          return self['008'].value[22,2]
+        end
+      end
+    end  
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      next unless fxd_fld.value[0,1].match(/[ef]{1}/)
+      unless fxd_fld.value[5,2] == '  '
+        if human_readable
+          proj_map.each_key { | general |
+            next unless proj_map[general].keys.index(fxd_fld.value[5,2])
+            return [general,proj_map[general][fxd_fld.value[5,2]]]
+          }        
+        else
+          return fxd_fld.value[5,2]
+        end
+      end
+    }       
+    return false            
+  end
+  
+  def special_format(human_readable=false)
+    spfm_map = {'a'=>'Blueprint photocopy','b'=>'Other photocopy','c'=>'Negative photocopy',
+                'd'=>'Film negative','f'=>'Facsimile','g'=>'Relief model','h'=>'Rare (pre-1800)',
+                'e'=>'Manuscript','j'=>'Picture/post card','k'=>'Calendar','l'=>'Puzzle',
+                'm'=>'Braille, tactile','n'=>'Game','o'=>'Wall map','p'=>'Playing cards',
+                'q'=>'Loose-leaf','z'=>'Other'}
+    human_readable = spfm_map if human_readable
+    return self.field_parser({:match=>'MAP', :start=>33,:end=>2}, {:match=>/[ef]{1}/, :start=>16,:end=>2}, human_readable)                             
+  end
+end

data/lib/enhanced_marc/mixed_record.rb

@@ -0,0 +1,37 @@
+module MARC
+
+  # A class that represents an individual MARC record. Every record
+  # is made up of a collection of MARC::Field objects. 
+
+  class MixedRecord < Record
+
+    def initialize
+      super
+      @leader[6] = 'p' if @leader[6,1] == ' '
+      @leader[7] = 'c' if @leader[7,1] == ' '    
+      @record_type = 'MIX'  
+      @bibliographic_level = @leader.get_blvl
+      self.extend MixedType      
+      self.inspect_fixed_fields      
+    end
+    
+    def is_valid_type?
+      return false unless @leader[6,1].match('p')
+      return true
+    end
+    def is_valid_blvl?
+      return false unless @leader[7,1].match(/[cdi]{1}/)    
+      return true
+    end
+    def self.new_from_record(record)
+      rec = MixedRecord.new
+      record.instance_variables.each { | var |
+        rec.instance_variable_set(var, record.instance_variable_get(var))
+      }
+      return Exception.new("Incorrect type declaration in leader") unless rec.is_valid_type?
+      return Exception.new("Incorrect bibliographic declaration in leader") unless rec.is_valid_blvl?
+      return rec
+    end    
+    
+  end
+end

data/lib/enhanced_marc/mixed_type.rb

@@ -0,0 +1,4 @@
+module MixedType
+  include RecordType
+  public :form
+end

data/lib/enhanced_marc/reader.rb

@@ -0,0 +1,105 @@
+module MARC
+  class Reader
+    # A static method for turning raw MARC data in transission
+    # format into a MARC::Record object.
+    def self.decode(marc, params={})
+      leader = Leader.new(marc[0..LEADER_LENGTH-1])
+      begin
+        record = case leader.get_type
+          when 'BKS' then MARC::BookRecord.new
+          when 'SER' then MARC::SerialRecord.new
+          when 'VIS' then MARC::VisualRecord.new
+          when 'MIX' then MARC::MixedRecord.new
+          when 'MAP' then MARC::MapRecord.new
+          when 'SCO' then MARC::ScoreRecord.new
+          when 'REC' then MARC::SoundRecord.new
+          when 'COM' then MARC::ComputerRecord.new
+          else MARC::Record.new
+        end
+      rescue ArgumentError
+        record = MARC::Record.new
+      end
+      record.leader = leader
+
+      # 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]
+
+      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 data field
+        if tag < '010'
+          record.append(MARC::ControlField.new(tag,field_data))
+        else
+          field = MARC::DataField.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
+end

data/lib/enhanced_marc/record.rb

@@ -0,0 +1,96 @@
+module MARC
+  class Record
+    
+    attr_reader :record_type, :bibliographic_level
+    
+    # Creates a new MARC::Record using MARC::Leader
+    # to work with the leader, rather than a string
+    def initialize
+      @fields = []
+      @leader = Leader.new(' ' * 24) 
+    end
+            
+    def contains_type?(record_type)
+      type_map = {"BKS"=>/[at]{1}/, "COM"=>"m", "MAP"=>/[ef]{1}/,"MIX"=>"p", "SCO"=>/[cd]{1}/, "REC"=>/[ij]{1}/, "SER"=>"s", "VIS"=>/[gkor]{1}/}
+      matching_fields = []
+      @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+        matching_fields << fxd_fld if fxd_fld.value[0,1].match(type_map[record_type])
+      
+      }
+      return nil if matching_fields.empty?
+      return matching_fields
+    end 
+    
+    def self.new_from_record(record)
+      leader = Leader.new(record.leader)
+      case leader.get_type
+        when 'BKS' then return MARC::BookRecord.new_from_record(record)
+        when 'SER' then return MARC::SerialRecord.new_from_record(record)
+        when 'VIS' then return MARC::VisualRecord.new_from_record(record)
+        when 'MIX' then return MARC::MixedRecord.new_from_record(record)                
+        when 'MAP' then return MARC::MapRecord.new_from_record(record)                
+        when 'SCO' then return MARC::ScoreRecord.new_from_record(record)                
+        when 'REC' then return MARC::SoundRecord.new_from_record(record)                
+        when 'COM' then return MARC::ComputerRecord.new_from_record(record)                
+      end      
+    end    
+    
+    def to_typed_record
+      return self.new_from_record(self)
+    end  
+    
+    def is_archival?
+      return @leader.is_archival?
+    end
+        
+    
+    def composition_form(human_readable=false)
+    end
+    
+    
+    def publication_country
+      return self['008'].value[15,2] unless self['008'].value[15,2] == '  '
+      return false
+    end
+    
+    def get_dates
+    
+    end
+    
+    def created_on
+      unless self['008'].value[0,6] == (' '*6)
+        return Date.parse(self['008'].value[0,2]+'-'+self['008'].value[2,2]+'-'+self['008'].value[4,2], false)
+      else
+        return Date.today
+      end
+    end
+    
+    def inspect_fixed_fields
+      type_map = {/[at]{1}/=>BookType,'m'=>ComputerType,/[ef]{1}/=>MapType,
+        'p'=>MixedType,/[cd]{1}/=>ScoreType,/[ij]{1}/=>SoundType,'s'=>SerialType,
+        /[gkor]{1}/=>VisualType}
+      @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |    
+        type_map.each_key { | key |
+          if fxd_fld.value[0,1].match(key)
+            self.extend type_map[key]
+          end
+        }
+      }
+    end
+    
+    def languages
+      languages = []
+      unless self['008'].value[35,3].empty?
+        languages << Locale::Info.get_language(self['008'].value[35,3])
+      end
+      oh_four_ones = @fields.find_all {|fld| fld.tag == "041"}
+      oh_four_ones.each do | oh_four_one |
+        langs = oh_four_one.find_all { |sub| sub.code == 'a'}
+        langs.each do | lang |
+          languages << Locale::Info.get_language(lang.value)
+        end
+      end
+      languages
+    end        
+  end
+end