rsinger-enhanced_marc 0.1 → 0.1.2

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,101 @@
+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])
+      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
+      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,81 @@
+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        
+  end
+end

data/lib/enhanced_marc/record_type.rb

@@ -0,0 +1,309 @@
+module RecordType
+  
+  private
+  
+  def is_govdoc?(human_readable=false)
+    govdoc_map={'a'=>'Autonomous or semiautonomous components', 'c'=>'Multilocal', 'f'=>'Federal',
+      'i'=>'International', 'l'=>'Local', 'm'=>'Multistate', 'o'=>'Undetermined', 's'=>'State', 'u'=>'Unknown', 'z'=>'Other'}
+    human_readable = govdoc_map if human_readable
+    return self.field_parser({:match=>/^BKS$|^COM$|^MAP$|^SER$|^VIS$/, :start=>28,:end=>1}, {:match=>/[atmefsgkor]{1}/, :start=>11,:end=>1}, human_readable)
+  end    
+  
+  def nature_of_contents(human_readable=false)
+    cont_map = {'a'=>'Abstracts','b'=>'Bibliography','c'=>'Catalog','d'=>'Dictionary',
+      'e'=>'Encyclopedia', 'f'=>'Handbook', 'g'=>'Legal article', 'h'=>'Biography', 'i'=>'Index',
+      'j'=>'Patent document', 'k'=>'Discography', 'l'=>'Legislation', 'm'=>'Thesis', 'n'=>'Literature survey',
+      'o'=>'Review', 'p'=>'Programmed text', 'q'=>'Filmography', 'r'=>'Directory', 's'=>'Statistics', 
+      't'=>'Technical report', 'u'=>'Standard/specification', 'v'=>'Legal case', 'w'=>'Law report', 'x'=>'Other report',
+      'z'=>'Treaty'}
+    contents = []
+    idx = nil
+    if self.record_type == 'BKS'
+      idx = 24
+      len = 4
+    elsif self.record_type == 'SER'
+      idx = 25
+      len = 3
+    end
+    if idx
+      self['008'].value[idx,len].split(//).each { | char | 
+        next if char == " "
+        if human_readable
+          contents << cont_map[char]
+        else
+          contents << char
+        end
+      }
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      idx = nil
+      if fxd_fld.value[0,1].match(/[at]{1}/)
+        idx = 7
+        len = 4
+      elsif fxd_fld.value[0,1].match('s')
+        idx = 8
+        len = 3
+      end     
+      if idx 
+        fxd_fld.value[idx,len].split(//).each { | char | 
+          next if char == " "
+          if human_readable
+            contents << cont_map[char]
+          else
+            contents << char
+          end
+        }
+      end
+    }       
+    return false if contents.empty?
+    return contents      
+  end
+  
+
+  def is_conference?
+    return true if self['008'].value[29,1] == '1' && @record_type.match(/^BKS$|^SER$/)      
+    return true if self['008'].value[30,2].match(/c/) && @record_type.match(/^SCO$|^REC$/) 
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      return true if fxd_fld.value[12,1] == '1' && fxd_fld.value[0,1].match(/[ats]{1}/)
+
+      return true if fxd_fld.value[13,2].match(/c/) && fxd_fld.value[0,1].match(/[cdij]{1}/)
+    }      
+    return false  
+  end
+  
+  def set_conference(value=false, field=nil)
+    if field
+      return Exception.new("Field is not an 006") unless field.tag == '006'
+      return Exception.new("Field is not a BKS or SER") unless field.value[0,1].match(/[ats]{1}/)
+      if value
+        field.value[12] = '1'
+      else
+        field.value[12] = '0'
+      end
+    else  
+      field = @fields['008']
+      field = MARC::Controlfield.new('008') unless field
+      if value
+        field[29] = '1'
+      else
+        field[29] = '0'
+      end
+    end    
+    
+  end  
+  
+  def accompanying_matter(human_readable=false)
+    accm_map = {'a'=>'Discography','b'=>'Bibliography','c'=>'Thematic index','d'=>'Libretto',
+      'e'=>'Composer biography', 'f'=>'Performer biography', 'g'=>'Technical/historical information on instruments', 
+      'h'=>'Technical information on music', 'i'=>'Historical information',
+      'k'=>'Ethnological information', 'r'=>'Instructional materials', 's'=>'Music', 
+      'z'=>'Other accompanying matter'}
+      matter = []
+
+      if ['SCO', 'REC'].index(@record_type)
+      self['008'].value[24,6].split(//).each { | char | 
+        next if char == " "
+        if human_readable
+          matter << accm_map[char]
+        else
+          matter << char
+        end
+      }
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+  
+      if fxd_fld.value[0,1].match(/[cdij]{1}/)
+        fxd_fld.value[7,6].split(//).each { | char | 
+          next if char == " "
+          if human_readable
+            matter << accm_map[char]
+          else
+            matter << char
+          end
+        }
+      end
+    }       
+    return false if matter.empty?
+    return matter          
+  end  
+  
+  def audience_level(human_readable=false)
+    audn_map = {'a'=>'Preschool', 'b'=>'Children age 6-8', 'c'=>'Children age 9-13',
+      'd'=>'Adolescent', 'e'=>'Adult', 'f'=>'Specialized', 'g'=>'General', 'j'=>'Juvenile'
+      }
+    human_readable = audn_map if human_readable
+    return self.field_parser({:match=>/^BKS$|^VIS$|^MIX$|^MAP$|^SCO$|^REC$|^COM$/, :start=>22,:end=>1}, {:match=>/[atmefpcdijgkor]{1}/, :start=>5,:end=>1}, human_readable)
+  end  
+  
+  def form(human_readable=false)
+    form_map = {'a'=>'Microfilm', 'b'=>'Microfiche', 'c'=>'Microopaque',
+      'd'=>'Large print', 'f'=>'Braille', 'r'=>'Reproduction', 's'=>'Electronic'
+    }
+    idx = nil
+    if self.record_type.match(/^MAP$|^VIS$/)
+      idx = 29
+    else
+      idx = 23
+    end
+    unless self['008'].value[idx,1] == ' '
+      if human_readable
+        return form_map[self['008'].value[idx,1]]
+      else
+        return self['008'].value[idx,1]
+      end
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      idx = nil
+      if fxd_fld.value[0,1].match(/[efgkor]{1}/)
+        idx = 6
+      else
+        idx = 12
+      end     
+      next if fxd_fld.value[idx,1] == ' '        
+      if human_readable
+        return form_map[fxd_fld.value[idx,1]]
+      else
+        return fxd_fld.value[idx,1]
+      end        
+    }       
+    return false
+  end
+  
+  def has_index?
+    return true if self['008'].value[31,1] == '1'      
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      return true if fxd_fld.value[14,1] == '1'
+    }      
+    return false      
+  end
+  
+  def composition_form(human_readable=false)
+    comp_map = {'an'=>'Anthem','bd'=>'Ballad','bt'=>'Ballet','bg'=>'Bluegrass music',
+      'bl'=>'Blues','cn'=>'Canon or round','ct'=>'Catata','cz'=>'Canzona','cr'=>'Carol',
+      'ca'=>'Chaconne','cs'=>'Chance composition','cp'=>'Polyphonic chanson','cc'=>'Christian chant',
+      'cb'=>'Chant','cl'=>'Chorale prelude','ch'=>'Chorale','cg'=>'Concerti grossi','co'=>'Concerto',
+      'cy'=>'Country music','df'=>'Dance form','dv'=>'Divertimento/serenade/cassation/divertissement/notturni',
+      'ft'=>'Fantasia','fm'=>'Folk music','fg'=>'Fugue','gm'=>'Gospel music','hy'=>"Hymn",'jz'=>'Jazz',
+      'md'=>'Madrigal','mr'=>'March','ms'=>'Mass','mz'=>'Mazurka','mi'=>'Minuet','mo'=>'Motet',
+      'mp'=>'Motion picture music','mu'=>'Multiple forms','mc'=>'Musical revue/comedy',
+      'nc'=>'Nocturne','nn'=>'Not a musical recording','op'=>'Opera','or'=>'Oratorio',
+      'ov'=>'Overture','pt'=>'Part-song','ps'=>'Passacaglia','pm'=>'Passion music',
+      'pv'=>'Pavanes','po'=>'Polonaises','pp'=>'Popular music','pr'=>'Prelude','pg'=>'Program music',
+      'rg'=>'Ragtime music','rq'=>'Requiem','rp'=>'Rhapsody','ri'=>'Ricercars','rc'=>'Rock music',
+      'rd'=>'Rondo','sn'=>'Sonata','sg'=>'Song','sd'=>'Square dance music','st'=>'Study/exercise',
+      'su'=>'Suite','sp'=>'Symphonic poem','sy'=>'Symphony','tc'=>'Toccata','ts'=>'Trio-sonata',
+      'uu'=>'Unknown','vr'=>'Variation','wz'=>'Waltz','zz'=>'Other'      
+      }
+    if @record_type.match(/^SCO$|^REC$/)
+      unless self['008'].value[18,2] == '  '
+        if human_readable
+          return comp_map[self['008'].value[18,2]]
+        else
+          return self['008'].value[18,2]
+        end
+      end
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      next unless fxd_fld.value[0,1].match(/[cdij]{1}/)
+      unless fxd_fld.value[1,2] == '  '
+        if human_readable
+          return comp_map[fxd_fld.value[1,2]]
+        else
+          return fxd_fld.value[1,2]
+        end
+      end
+    }       
+    return false      
+  end
+  
+  def music_format(human_readable=false)
+    fmus_map = {'a'=>'Full score','b'=>'Full score, miniature/study size','c'=>'Accompaniment reduced for keyboard',
+      'd'=>'Voice score','e'=>'Condensed score','g'=>'Close score','m'=>'Multiple formats','n'=>'N/A',
+      'u'=>'Unknown','z'=>'Other'}
+    human_readable = fmus_map if human_readable
+    return self.field_parser({:match=>/^SCO$|^REC$/, :start=>20,:end=>1}, {:match=>/[cdij]{1}/, :start=>3,:end=>1}, human_readable)
+#    if self.record_type.match(/^SCO$|^REC$/)
+#      unless self['008'].value[20,1] == ' '
+#        if human_readable
+#          return fmus_map[self['008'].value[20,1]]
+#        else
+#          return self['008'].value[20,1]
+#        end
+#      end
+#    end
+##    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+ #     next unless fxd_fld.value[0,1].match(/[cdij]{1}/)   
+#      next if fxd_fld.value[3,1] == ' '        
+#      if human_readable
+#        return fmus_map[fxd_fld.value[3,1]]
+#      else
+#        return fxd_fld.value[3,1]
+#      end        
+ #   }       
+ #   return false
+  end
+  
+  def has_index?
+    return true if self['008'].value[31,1] == '1'      
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      return true if fxd_fld.value[14,1] == '1'
+    }      
+    return false            
+  end
+  
+  def literary_text(human_readable=true)
+    ltxt_map = {'a'=>'Autobiography', 'b'=>'Biography','c'=>'Conference proceeding','d'=>'Drama',
+      'e'=>'Essay','f'=>'Fiction','g'=>'Reporting','h'=>'History','i'=>'Instruction','j'=>'Language instruction',
+      'k'=>'Comedy','l'=>'Lecture/speech','m'=>'Memoir','n'=>'N/A','o'=>'Folktale','p'=>'Poetry','r'=>'Rehearsal',
+      's'=>'Sounds','t'=>'Interview','z'=>'Other'}
+      txts = []
+      
+      if ['SCO', 'REC'].index(@record_type)
+      self['008'].value[30,2].split(//).each { | char | 
+        next if char == " "
+        if human_readable
+          txts << ltxt_map[char]
+        else
+          txts << char
+        end
+      }
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+  
+      if fxd_fld.value[0,1].match(/[cdij]{1}/)
+        fxd_fld.value[13,2].split(//).each { | char | 
+          next if char == " "
+          if human_readable
+            txts << ltxt_map[char]
+          else
+            txts << char
+          end
+        }
+      end
+    }       
+    return false if txts.empty?
+    return txts          
+  end
+  protected
+  def field_parser(eight, six, human_readable_map=nil)
+    if self.record_type.match(eight[:match])
+      unless self['008'].value[eight[:start],eight[:end]] == ' '*eight[:end]
+        if human_readable_map
+          return human_readable_map[self['008'].value[eight[:start],eight[:end]]]
+        else
+          return self['008'].value[eight[:start],eight[:end]]
+        end
+      end
+    end
+    @fields.find_all {|f| ('006') === f.tag}.each { | fxd_fld |
+      next unless fxd_fld.value[0,1].match(six[:match])   
+      next if fxd_fld.value[six[:start],six[:end]] == ' '*six[:end]
+      if human_readable_map
+        return human_readable_map[fxd_fld.value[six[:start],six[:end]]]
+      else
+        return fxd_fld.value[six[:start],six[:end]]
+      end        
+    }       
+    return false  
+  end
+end