marc 1.1.1 → 1.2.0

data/Rakefile

@@ -1,22 +1,22 @@
-require 'rubygems'
+require "rubygems"
 
-require 'rake'
-require 'rake/testtask'
-require 'rdoc/task'
-require 'bundler/gem_tasks'
+require "rake"
+require "rake/testtask"
+require "rdoc/task"
+require "bundler/gem_tasks"
+require "standard/rake"
 
+task default: [:test]
+task format: "standard:fix"
 
-task :default => [:test]
-
-Rake::TestTask.new('test') do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/tc_*.rb'
+Rake::TestTask.new("test") do |t|
+  t.libs << "lib"
+  t.pattern = "test/**/tc_*.rb"
   t.verbose = true
 end
 
-
-Rake::RDocTask.new('doc') do |rd|
+Rake::RDocTask.new("doc") do |rd|
   rd.rdoc_files.include("README", "Changes", "LICENSE", "lib/**/*.rb")
-  rd.main = 'MARC::Record'
-  rd.rdoc_dir = 'doc'
+  rd.main = "MARC::Record"
+  rd.rdoc_dir = "doc"
 end

data/bin/marc

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'marc'
+
+# the filename
+filename = ARGV[0]
+
+reader = MARC::ForgivingReader.new(filename)
+
+reader.each { |record|
+    puts record
+}
+
+

data/bin/marc2xml

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'marc'
+
+# the filename
+filename = ARGV[0]
+
+reader = MARC::ForgivingReader.new(filename)
+writer = MARC::XMLWriter.new($stdout)
+
+reader.each { |record|
+  writer.write(record)
+}
+
+writer.close
+
+

data/examples/xml2marc.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# usage: xml2marc.rb marc.xml > marc.dat
+
+require "marc"
+
+reader = MARC::XMLReader.new(ARGV.shift)
+reader.each do |record|
+  $stdout.write(record.to_marc)
+end

data/lib/marc/constants.rb

@@ -1,5 +1,6 @@
-module MARC
+# frozen_string_literal: true
 
+module MARC
   # constants used in MARC21 reading/writing
   LEADER_LENGTH = 24
   DIRECTORY_ENTRY_LENGTH = 12
@@ -7,12 +8,11 @@ module MARC
   END_OF_FIELD = 0x1E.chr
   END_OF_RECORD = 0x1D.chr
 
-  # constants used in XML reading/writing 
+  # 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"
 
   # marc-hash
   MARCHASH_MAJOR_VERSION = 1
   MARCHASH_MINOR_VERSION = 0
-  
 end

data/lib/marc/controlfield.rb

@@ -1,23 +1,21 @@
-require 'set'
+require "set"
 
 module MARC
-
-  # MARC records contain control fields, each of which has a 
+  # MARC records contain control fields, each of which has a
   # tag and value. Tags for control fields must be in the
   # 001-009 range or be specially added to the @@control_tags Set
 
   class ControlField
-    
     # Initially, control tags are the numbers 1 through 9 or the string '000'
-    @@control_tags = Set.new(%w{000 001 002 003 004 005 006 007 008 009})
- 
+    @@control_tags = Set.new(%w[000 001 002 003 004 005 006 007 008 009])
+
     def self.control_tags
-      return @@control_tags
+      @@control_tags
     end
 
     # A tag is a control tag if tag.to_s is a member of the @@control_tags set.
     def self.control_tag?(tag)
-      return @@control_tags.include? tag.to_s
+      @@control_tags.include? tag.to_s
     end
 
     # the tag value (007, 008, etc)
@@ -26,46 +24,60 @@ module MARC
     # the value of the control field
     attr_accessor :value
 
-    # The constructor which must be passed a tag value and 
+    # The constructor which must be passed a tag value and
     # an optional value for the field.
 
-    def initialize(tag,value='')
+    def initialize(tag, value = "")
       @tag = tag
       @value = value
-      if not MARC::ControlField.control_tag?(@tag)
-        raise MARC::Exception.new(), "tag must be in 001-009 or in the MARC::ControlField.control_tags set"
+    end
+
+    # Returns true if there are no error messages associated with the field
+    def valid?
+      errors.none?
+    end
+
+    # Returns an array of validation errors
+    def errors
+      messages = []
+
+      unless MARC::ControlField.control_tag?(@tag)
+        messages << "tag #{@tag.inspect} must be in 001-009 or in the MARC::ControlField.control_tags set"
       end
+
+      messages
     end
 
     # Two control fields are equal if their tags and values are equal.
 
     def ==(other)
+      if !other.is_a?(ControlField)
+        return false
+      end
       if @tag != other.tag
-        return false 
+        return false
       elsif @value != other.value
         return false
       end
-      return true
+      true
     end
 
     # turning it into a marc-hash element
     def to_marchash
-      return [@tag, @value]
+      [@tag, @value]
     end
-    
+
     # Turn the control field into a hash for MARC-in-JSON
     def to_hash
-      return {@tag=>@value}
+      {@tag => @value}
     end
-    
+
     def to_s
-      return "#{tag} #{value}" 
+      "#{tag} #{value}"
     end
 
     def =~(regex)
-      return self.to_s =~ regex
-    end      
-
+      to_s =~ regex
+    end
   end
-
 end

data/lib/marc/datafield.rb

@@ -1,11 +1,11 @@
 module MARC
-  # MARC records contain data fields, each of which has a tag, 
+  # MARC records contain data fields, each of which has a tag,
   # indicators and subfields. Tags for data fields must are all
   # three-character tags that are not control fields (generally,
   # any numeric tag greater than 009).
   #
   # Accessor attributes: tag, indicator1, indicator2
-  # 
+  #
   # DataField mixes in Enumerable to enable access to it's constituent
   # Subfield objects. For instance, if you have a DataField representing
   # a 856 tag, and want to find all 'z' subfields:
@@ -14,7 +14,7 @@ module MARC
   #
   # Also, the accessor 'subfields' is an array of MARC::Subfield objects
   # which can be accessed or modified by the client directly if
-  # neccesary. 
+  # neccesary.
 
   class DataField
     include Enumerable
@@ -31,90 +31,100 @@ module MARC
     # 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, 
-    # 
+    # Subfields are passed in as comma separated list of
+    # MARC::Subfield objects,
+    #
     #   field = MARC::DataField.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::DataField.new('245','0','0',
     #     ['a', 'Consilience :'],['b','the unity of knowledge '],
     #     ['c', 'by Edward O. Wilson.'] )
 
-    def initialize(tag, i1=' ', i2=' ', *subfields)
-      # if the tag is less than 3 characters long and 
+    def initialize(tag, i1 = " ", i2 = " ", *subfields)
+      # if the tag is less than 3 characters long and
       # the string is all numeric then we pad with zeros
-      if tag.length < 3 and /^[0-9]+$/ =~ tag
-        @tag = "%03d" % tag
+      @tag = if (tag.length < 3) && (/^[0-9]+$/ =~ tag)
+        "%03d" % tag
       else
-        @tag = tag 
+        tag
       end
-      # can't allow nil to be passed in or else it'll 
+      # 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 = []
+      @indicator1 = i1.nil? ? " " : i1
+      @indicator2 = i2.nil? ? " " : i2
 
-      # must use MARC::ControlField for tags < 010 or
-      # those in MARC::ControlField#extra_control_fields
-      
-      if MARC::ControlField.control_tag?(@tag)
-        raise MARC::Exception.new(),
-          "MARC::DataField objects can't have ControlField tag '" + @tag + "')"
-      end
+      @subfields = []
 
       # allows MARC::Subfield objects to be passed directly
       # or a shorthand of ['a','Foo'], ['b','Bar']
-      subfields.each do |subfield| 
+      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: " + subfield.to_s 
+            raise MARC::Exception.new,
+              "arrays must only have 2 elements: " + subfield.to_s
           end
           @subfields.push(
-            MARC::Subfield.new(subfield[0],subfield[1]))
-        else 
-          raise MARC::Exception.new(), 
+            MARC::Subfield.new(subfield[0], subfield[1])
+          )
+        else
+          raise MARC::Exception.new,
             "invalid subfield type #{subfield.class}"
         end
       end
     end
 
+    # Returns true if there are no error messages associated with the field
+    def valid?
+      errors.none?
+    end
+
+    # Returns an array of validation errors
+    def errors
+      messages = []
+
+      # must use MARC::ControlField for tags < 010 or
+      # those in MARC::ControlField#extra_control_fields
+
+      if MARC::ControlField.control_tag?(@tag)
+        messages << "MARC::DataField objects can't have ControlField tag '" + @tag + "'"
+      end
+
+      messages
+    end
 
     # 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} " 
+      str += "#{indicator1}#{indicator2} "
       @subfields.each { |subfield| str += subfield.to_s }
-      return str
+      str
     end
 
     # Turn into a marc-hash structure
     def to_marchash
-      return [@tag, @indicator1, @indicator2, @subfields.map {|sf| [sf.code, sf.value]} ]
+      [@tag, @indicator1, @indicator2, @subfields.map { |sf| [sf.code, sf.value] }]
     end
-    
+
     # Turn the variable field and subfields into a hash for MARC-in-JSON
-    
+
     def to_hash
-      field_hash = {@tag=>{'ind1'=>@indicator1,'ind2'=>@indicator2,'subfields'=>[]}}
-      self.each do |subfield|
-        field_hash[@tag]['subfields'] << {subfield.code=>subfield.value}
+      field_hash = {@tag => {"ind1" => @indicator1, "ind2" => @indicator2, "subfields" => []}}
+      each do |subfield|
+        field_hash[@tag]["subfields"] << {subfield.code => subfield.value}
       end
       field_hash
-    end    
+    end
 
     # Add a subfield (MARC::Subfield) to the field
     #    field.append(MARC::Subfield.new('a','Dave Thomas'))
@@ -123,72 +133,69 @@ module MARC
       @subfields.push(subfield)
     end
 
-    
-
     # You can iterate through the subfields in a Field:
     #   field.each {|s| print s}
 
     def each
-      for subfield in subfields
+      subfields.each do |subfield|
         yield subfield
       end
     end
 
-    #def each_by_code(filter)
+    # def each_by_code(filter)
     #  @subfields.each_by_code(filter)
-    #end
+    # end
 
-    # You can lookup subfields with this shorthand. Note it 
+    # 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}
+      subfield = find { |s| s.code == code }
       return subfield.value if subfield
-      return
+      nil
     end
- 
 
-    def codes(dedup=true)
+    def codes(dedup = true)
       codes = []
-      @subfields.each {|s| codes << s.code }
+      @subfields.each { |s| codes << s.code }
       dedup ? codes.uniq : codes
     end
 
-    # Two fields are equal if their tag, indicators and 
+    # Two fields are equal if their tag, indicators and
     # subfields are all equal.
 
     def ==(other)
+      if !other.is_a?(DataField)
+        return false
+      end
       if @tag != other.tag
-        return false 
+        return false
       elsif @indicator1 != other.indicator1
-        return false 
+        return false
       elsif @indicator2 != other.indicator2
-        return false 
+        return false
       elsif @subfields != other.subfields
         return false
       end
-      return true
+      true
     end
 
-
     # To support regex matching with fields
     #
     #   if field =~ /Huckleberry/ ...
 
     def =~(regex)
-      return self.to_s =~ regex
+      to_s =~ regex
     end
 
-
     # to get the field as a string, without the tag and indicators
     # useful in situations where you want a legible version of the field
     #
     # print record['245'].value
 
     def value
-      return(@subfields.map {|s| s.value} .join '')
+      (@subfields.map { |s| s.value }.join "")
     end
-
   end
 end

data/lib/marc/dublincore.rb

@@ -1,79 +1,97 @@
 module MARC
-  
   # A class for mapping MARC records to Dublin Core
-  
-  class DublinCore
 
+  class DublinCore
     def self.map(record)
-      dc_hash = Hash.new
-      dc_hash['title'] = get_field_value(record['245']['a'])
+      dc_hash = {}
+      dc_hash["title"] = get_field_value(record["245"]["a"])
 
       # Creator
-      [100, 110, 111, 700, 710, 711, 720].each do |field|
-        dc_hash['creator'] ||= []
-        dc_hash['creator'] << get_field_value(record[field.to_s])
+      ["100", "110", "111", "700", "710", "711", "720"].each do |field|
+        dc_hash["creator"] ||= []
+        dc_hash["creator"] << get_field_value(record[field])
       end
 
       # Subject
-      [600, 610, 611, 630, 650, 653].each do |field|
-        dc_hash['subject'] ||= []
-        dc_hash['subject'] << get_field_value(record[field.to_s])
+      ["600", "610", "611", "630", "650", "653"].each do |field|
+        dc_hash["subject"] ||= []
+        dc_hash["subject"] << get_field_value(record[field])
       end
 
       # Description
-      [500..599].each do |field|
-        next if [506, 530, 540, 546].include?(field)
-        dc_hash['description'] ||= []
-        dc_hash['description'] << get_field_value(record[field.to_s])
+      ("500".."599").each do |field|
+        next if ["506", "530", "540", "546"].include?(field)
+        dc_hash["description"] ||= []
+        dc_hash["description"] << get_field_value(record[field])
       end
 
-      dc_hash['publisher'] = get_field_value(record['260']['a']['b']) rescue nil
-      dc_hash['date'] = get_field_value(record['260']['c']) rescue nil
-      dc_hash['type'] = get_field_value(record['655']) 
-      dc_hash['format'] = get_field_value(record['856']['q']) rescue nil
-      dc_hash['identifier'] = get_field_value(record['856']['u']) rescue nil
-      dc_hash['source'] = get_field_value(record['786']['o']['t']) rescue nil
-      dc_hash['language'] = get_field_value(record['546'])
+      dc_hash["publisher"] = begin
+        get_field_value(record["260"]["a"]["b"])
+      rescue
+        nil
+      end
+      dc_hash["date"] = begin
+        get_field_value(record["260"]["c"])
+      rescue
+        nil
+      end
+      dc_hash["type"] = get_field_value(record["655"])
+      dc_hash["format"] = begin
+        get_field_value(record["856"]["q"])
+      rescue
+        nil
+      end
+      dc_hash["identifier"] = begin
+        get_field_value(record["856"]["u"])
+      rescue
+        nil
+      end
+      dc_hash["source"] = begin
+        get_field_value(record["786"]["o"]["t"])
+      rescue
+        nil
+      end
+      dc_hash["language"] = get_field_value(record["546"])
 
-      dc_hash['relation'] = []
-      dc_hash['relation'] << get_field_value(record['530'])
-      [760..787].each do |field|
-        dc_hash['relation'] << get_field_value(record[field.to_s]['o']['t']) rescue nil
+      dc_hash["relation"] = []
+      dc_hash["relation"] << get_field_value(record["530"])
+      ("760".."787").each do |field|
+        dc_hash["relation"] << get_field_value(record[field]["o"]["t"])
+      rescue
+        nil
       end
 
-      [651, 752].each do |field|
-        dc_hash['coverage'] ||= []
-        dc_hash['coverage'] << get_field_value(record[field.to_s])
+      ["651", "752"].each do |field|
+        dc_hash["coverage"] ||= []
+        dc_hash["coverage"] << get_field_value(record[field])
       end
 
-      [506, 540].each do |field|
-        dc_hash['rights'] ||= []
-        dc_hash['rights'] << get_field_value(record[field.to_s])
+      ["506", "540"].each do |field|
+        dc_hash["rights"] ||= []
+        dc_hash["rights"] << get_field_value(record[field])
       end
-      
-      dc_hash.keys.each do |key| 
+
+      dc_hash.keys.each do |key|
         dc_hash[key].flatten! if dc_hash[key].respond_to?(:flatten!)
         dc_hash[key].compact! if dc_hash[key].respond_to?(:compact!)
       end
-      
+
       dc_hash
     end
-      
+
     def self.get_field_value(field)
       return if field.nil?
-      
-      if !field.kind_of?(String) && field.respond_to?(:each)
+
+      if !field.is_a?(String) && field.respond_to?(:each)
         values = []
         field.each do |element|
           values << get_field_value(element)
         end
         values
       else
-        return field if field.kind_of?(String)
+        return field if field.is_a?(String)
         return field.value if field.respond_to?(:value)
       end
     end
-    
   end
 end
-

data/lib/marc/exception.rb

@@ -1,9 +1,17 @@
 module MARC
-
   # basic exception class for exceptions that
   # can occur during MARC processing.
 
   class Exception < RuntimeError
   end
 
+  class RecordException < MARC::Exception
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+      id = @record["001"] || "<record with no 001>"
+      super("Record #{id}: #{@record.errors.join("\n....")}")
+    end
+  end
 end

data/lib/marc/jsonl_reader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MARC
+  # Read marc-in-json documents from a `.jsonl` file -- also called
+  # "newline-delimited JSON", which is a file with one JSON document on each line.
+  class JSONLReader
+    include Enumerable
+
+    # @param [String, IO] file A filename, or open File/IO type object, from which to read
+    def initialize(file)
+      if file.is_a?(String)
+        raise ArgumentError.new("File '#{file}' can't be found") unless File.exist?(file)
+        raise ArgumentError.new("File '#{file}' can't be opened for reading") unless File.readable?(file)
+        @handle = File.new(file)
+      elsif file.respond_to?(:read, 5)
+        @handle = file
+      else
+        raise ArgumentError, "must pass in path or file"
+      end
+    end
+
+    # Turn marc-in-json lines into actual marc records and yield them
+    # @yieldreturn [MARC::Record] record created from each line of the file
+    def each
+      return enum_for(:each) unless block_given?
+      @handle.each do |line|
+        yield MARC::Record.new_from_hash(JSON.parse(line))
+      end
+    end
+  end
+end