enhanced_marc 0.2.3 → 0.3.0

data/lib/enhanced_marc/computer_type.rb

@@ -1,14 +1,17 @@
+# Methods for Computer records
 module ComputerType
   include RecordType
-  public :form, :audience_level, :is_govdoc?
-  def file_type(human_readable=false)
-    return false unless self.contains_type?("COM")
-    file_map = {'a'=>'Numeric data', 'b'=>'Computer program', 'c'=>'Representational',
-      'd'=>'Document', 'e'=>'Bibliographic data', 'f'=>'Font', 'g'=>'Game',
-      'h'=>'Sounds', 'i'=>'Interactive multimedia', 'j'=>'Online', 'm'=>'Combination',
-      'u'=>'Unknown', 'z'=>'Other'}
+  public :form, :audience_level, :is_govdoc?, :govdoc?, :conference?
+  def file_type(human_readable = false)
+    return false unless contains_type?('COM')
+    file_map = { 'a' => 'Numeric data', 'b' => 'Computer program',
+                 'c' => 'Representational', 'd' => 'Document',
+                 'e' => 'Bibliographic data', 'f' => 'Font', 'g' => 'Game',
+                 'h' => 'Sounds', 'i' => 'Interactive multimedia',
+                 'j' => 'Online', 'm' => 'Combination', 'u' => 'Unknown',
+                 'z' => 'Other' }
     human_readable = file_map if human_readable
-    return self.field_parser({:match=>'COM', :start=>26,:end=>1}, {:match=>'m', :start=>9,:end=>1}, human_readable)        
-  end    
-
-end
+    field_parser({ match: 'COM', start: 26, end: 1 },
+                 { match: 'm', start: 9, end: 1 }, human_readable)
+  end
+end

data/lib/enhanced_marc/leader.rb

@@ -1,132 +1,130 @@
 module MARC
-  
+
   # A class for accessing the MARC Leader
   class Leader < String
-    attr_reader :leader, :record_type, :bibliographic_level, :encoding_level, :fixed_fields
+    attr_reader :leader, :fixed_fields
     def initialize(leader)
-      super  
+      super
       # leader defaults:
       # http://www.loc.gov/marc/bibliographic/ecbdldrd.html
       self[10..11] = '22'
-      self[20..23] = '4500'           
-    end
-    
-    def parse_leader
-      self.get_type
-      self.get_blvl
-      self.get_elvl
+      self[20..23] = '4500'
     end
-    
-    def get_type_code
-      return self[6,1]    
+
+    def type_code
+      self[6, 1]
     end
-    
-    def get_blvl_code
-      return self[7,1]
+
+    alias get_type_code type_code
+
+    def blvl_code
+      self[7, 1]
     end
-    
-    def get_type
-      return @record_type = self.type_translator(self.get_type_code, self.get_blvl_code)
+
+    alias get_blvl_code blvl_code
+
+    def record_type
+      type_translator(get_type_code, get_blvl_code)
     end
-    
-    def is_archival?
-      return true if self[8,1] == 'a'
-      return false
+
+    alias get_type record_type
+
+    def archival?
+      return true if self[8, 1] == 'a'
+      false
     end
 
-    def get_blvl
+    alias is_archival? archival?
+
+    def blvl
       blvls = {
-        'a'=>'Monographic component part',
-        'b'=>'Serial component part',
-        'c'=>'Collection',
-        'd'=>'Subunit',
-        'i'=>'Integrating resource',
-        'm'=>'Monograph/Item',
-        's'=>'Serial'
+        'a' => 'Monographic component part',
+        'b' => 'Serial component part',
+        'c' => 'Collection',
+        'd' => 'Subunit',
+        'i' => 'Integrating resource',
+        'm' => 'Monograph/Item',
+        's' => 'Serial'
       }
-      return @bibliographic_level = blvls[self.get_blvl_code]
+      blvls[get_blvl_code]
     end
 
-    def set_type(type)
+    alias bibliographic_level blvl
+    alias get_blvl blvl
+
+    def record_type=(type)
       if type.length == 1
-        translated_type = self.types(type)
-        raise ArgumentError, "Invalid Type" if translated_type.nil?
+        translated_type = types(type)
+        raise ArgumentError, 'Invalid Type' if translated_type.nil?
       elsif type.length > 1
-        translated_type = type
-        type = self.types(type)
-        raise ArgumentError, "Invalid Type" if type.nil?
+        type = types(type)
+        raise ArgumentError, 'Invalid Type' if type.nil?
       else
-        raise ArgumentError, "Invalid Type"
-      end      
-      self[6] = type 
+        raise ArgumentError, 'Invalid Type'
+      end
+      self[6] = type
     end
-    
+
+    alias set_type record_type=
+
     def type_translator(type_code, blvl_code)
-      valid_types = ['a','t','g','k','r','o','p','e','f','c','d','i','j','m']
-      unless valid_types.index(type_code)    
-        raise ArgumentError, "Invalid Type!" 
-        return
-      end
+      valid_types = %w[a t g k r o p e f c d i j m]
+      raise ArgumentError, 'Invalid Type!' unless valid_types.index(type_code)
+
       rec_types = {
-        'BKS' => { :type => /[at]{1}/,	:blvl => /[acdm]{1}/ },
-	      'SER' => { :type => /[a]{1}/,	:blvl => /[bs]{1}/ },
-        'VIS' => { :type => /[gkro]{1}/,	:blvl => /[abcdims]{1}/ },
-        'MIX' => { :type => /[p]{1}/,	:blvl => /[cd]{1}/ },
-        'MAP' => { :type => /[ef]{1}/,	:blvl => /[abcdims]{1}/ },
-        'SCO' => { :type => /[cd]{1}/,	:blvl => /[abcdims]{1}/ },
-        'REC' => { :type => /[ij]{1}/,	:blvl => /[abcdims]{1}/ },
-        'COM' => { :type => /[m]{1}/,	:blvl => /[abcdims]{1}/ }
-      } 
-      
-      rec_types.each_key { | type |
-        return type if type_code.match(rec_types[type][:type]) and blvl_code.match(rec_types[type][:blvl])
-      } 
-      raise ArgumentError, "Invalid BLvl!"
-      return nil
-    end
-    
-    def get_elvl_code
-      return self[17,1]
-    end
-    
-    def get_elvl
-      elvls = {
-        ' '=>'Full',
-        '1'=>'Full, not examined',
-        '2'=>'Less-than-full',
-        '3'=>'Abbreviated',
-        '4'=>'Core',
-        '5'=>'Partial',
-        '7'=>'Minimal',
-        '8'=>'Prepublication',
-        'I'=>'Full-level input by OCLC participants',
-        'K'=>'Less-than-full input by OCLC participants',
-        'L'=>'Full-level input added from a batch process',
-        'M'=>'Less-than-full added from a batch process',
-        'E'=>'System-identified MARC error in batchloaded record',
-        'J'=>'Deleted record'
+        'BKS' => { type: /[at]{1}/,	blvl: /[acdm]{1}/ },
+        'SER' => { type: /[a]{1}/,	blvl: /[bs]{1}/ },
+        'VIS' => { type: /[gkro]{1}/,	blvl: /[abcdims]{1}/ },
+        'MIX' => { type: /[p]{1}/,	blvl: /[cd]{1}/ },
+        'MAP' => { type: /[ef]{1}/,	blvl: /[abcdims]{1}/ },
+        'SCO' => { type: /[cd]{1}/,	blvl: /[abcdims]{1}/ },
+        'REC' => { type: /[ij]{1}/,	blvl: /[abcdims]{1}/ },
+        'COM' => { type: /[m]{1}/,	blvl: /[abcdims]{1}/ }
       }
-      return @encoding_level = elvls[self.get_elvl_code]
+
+      rec_types.each_key do |type|
+        if type_code.match(rec_types[type][:type]) && blvl_code.match(rec_types[type][:blvl])
+          return type
+        end
+      end
+      raise ArgumentError, 'Invalid BLvl!'
     end
-    
-    def ELvl
-      self.get_elvl unless @encoding_level
-      return @encoding_level
+
+    def elvl_code
+      self[17, 1]
     end
-    
-    def get_desc_code
-      return self[18,1]
+    alias get_elvl_code elvl_code
+
+    def elvl
+      elvls = { ' ' => 'Full', '1' => 'Full, not examined',
+                '2' => 'Less-than-full', '3' => 'Abbreviated',
+                '4' => 'Core', '5' => 'Partial', '7' => 'Minimal',
+                '8' => 'Prepublication', 'J' => 'Deleted record',
+                'I' => 'Full-level input by OCLC participants',
+                'K' => 'Less-than-full input by OCLC participants',
+                'L' => 'Full-level input added from a batch process',
+                'M' => 'Less-than-full added from a batch process',
+                'E' => 'System-identified MARC error in batchloaded record' }
+      elvls[get_elvl_code]
     end
-    
-    def get_desc
-      codes = {' '=>'Non-ISBD', 'a'=>'AACR2', 'i'=>'ISBD', 'u'=>'Unknown'}
-      return @descriptive_cataloging_form = codes[self.get_desc_code]      
+    alias encoding_level elvl
+    alias ELvl elvl
+    alias get_elvl elvl
+
+    def desc_code
+      self[18, 1]
     end
-    
-    def Desc
-      self.get_desc unless @descriptive_cataloging_form
-      return @descriptive_cataloging_form
+
+    alias get_desc_code desc_code
+
+    def desc
+      codes = {
+        ' ' => 'Non-ISBD', 'a' => 'AACR2', 'i' => 'ISBD', 'u' => 'Unknown'
+      }
+      codes[get_desc_code]
     end
-    
+    alias descriptive_cataloging_form desc
+    alias Desc desc
+    alias get_desc desc
   end
 end

data/lib/enhanced_marc/map_record.rb

@@ -1,38 +1,46 @@
 module MARC
 
   # A class that represents an individual MARC record. Every record
-  # is made up of a collection of MARC::Field objects. 
-
+  # 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'  
+      @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      
+      extend MapType
+      inspect_fixed_fields
     end
-    
-    def is_valid_type?
-      return false unless @leader[6,1].match(/[ef]{1}/)
-      return true
+
+    def valid_type?
+      return false unless @leader[6, 1] =~ /[ef]{1}/
+      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
+    alias is_valid_type? valid_type?
+    def valid_blvl?
+      if @leader[7, 1] =~ /[acdim]{1}/ && @leader[6, 1] == 'f'
+        true
+      elsif @leader[7, 1] =~ /[abcdims]{1}/ && @leader[6, 1] == 'e'
+        true
+      else
+        false
+      end
     end
+    alias is_valid_blvl? valid_blvl?
     def self.new_from_record(record)
       rec = MapRecord.new
-      record.instance_variables.each { | var |
+      record.instance_variables.each do |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
+      error = rec.valid_type? ? nil : 'Incorrect type declaration in leader'
+      if !error && !rec.valid_blvl?
+        error = 'Incorrect bibliographic declaration in leader'
+      end
+      return Exception.new(error) if error
+      rec
+    end
+
   end
-end
+end

data/lib/enhanced_marc/map_type.rb

@@ -1,22 +1,26 @@
+# Methods for Map records
 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'}
+  public :is_govdoc?, :form, :has_index?, :govdoc?, :conference?
+  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)
+    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', 
+      '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 | 
+      self['008'].value[18,4].split(//).each { | char |
         next if char == " "
         if human_readable
           contents << relief_map[char]
@@ -26,8 +30,8 @@ module MapType
       }
     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 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]
@@ -35,11 +39,11 @@ module MapType
           contents << char
         end
       }
-    }       
+    }
     return false if contents.empty?
-    return contents        
+    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',
@@ -56,7 +60,7 @@ module MapType
                           },
                 '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'                          
+                          'dg'=>'Dymaxion','dh'=>'Cordiform','dl'=>'Lambert conformal','zz'=>'Other'
                 }
     }
     if @record_type == "MAP"
@@ -70,7 +74,7 @@ module MapType
           return self['008'].value[22,2]
         end
       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] == '  '
@@ -78,15 +82,15 @@ module MapType
           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            
+    }
+    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)',
@@ -94,6 +98,6 @@ module MapType
                 '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)                             
+    return self.field_parser({:match=>'MAP', :start=>33,:end=>2}, {:match=>/[ef]{1}/, :start=>16,:end=>2}, human_readable)
   end
-end
+end

data/lib/enhanced_marc/record.rb

@@ -1,7 +1,7 @@
 module MARC
   class Record
     
-    attr_reader :record_type, :bibliographic_level
+    attr_reader :record_type
     
     # Creates a new MARC::Record using MARC::Leader
     # to work with the leader, rather than a string
@@ -33,7 +33,7 @@ module MARC
         when 'SCO' then MARC::ScoreRecord.new_from_record(record)                
         when 'REC' then MARC::SoundRecord.new_from_record(record)                
         when 'COM' then MARC::ComputerRecord.new_from_record(record)                
-      end      
+      end
       typed_record.fields.reindex
       typed_record
     end    
@@ -50,6 +50,9 @@ module MARC
     def composition_form(human_readable=false)
     end
     
+    def bibliographic_level
+      @leader.get_blvl
+    end
     
     def publication_country
       return self['008'].value[15,3].strip unless self['008'].value[15,3] == '  '