marc4j4r 1.4.3-java

data/lib/marc4j4r/reader.rb

@@ -0,0 +1,129 @@
+import 'org.marc4j.ErrorHandler'
+require 'jlogger'
+
+module MarcReader
+  module LoggingNextRecord
+    def nextRecord(hashify=true)
+      begin
+        r = self.next
+      # rescue  Java::org.marc4j.MarcException => e
+      rescue   org.marc4j.MarcException => e
+        puts "#{e}"
+        raise e
+      end
+      self.logErrors if self.methods.include? 'errors'
+      r.hashify if hashify
+      return r
+    end    
+  end
+end
+
+module Java::OrgMarc4j::MarcReader
+  include Enumerable
+  include JLogger::Simple
+  
+  
+  def logErrors
+    return unless self.errors.getErrors
+    self.errors.getErrors.each do |err|
+      case err.severity
+      when ErrorHandler::MAJOR_ERROR
+        log.error err.toString
+      when ErrorHandler::ERROR_TYPO, ErrorHandler::MINOR_ERROR
+        self.log.warn err.toString
+      when ErrorHandler::INFO
+        log.info err.toString
+      when ErrorHandler::FATAL
+        log.error err.toString
+        Process.exit
+      end
+    end
+  end
+  
+  def nextRecord(hashify = true)
+    r = self.next
+    r.hashify if hashify
+    return r
+  end
+  
+  # Return the next record, after calling #hashify on it
+  def each(hashify=true)
+    while self.hasNext
+      r = self.nextRecord(hashify)
+      yield r
+    end
+  end  
+end
+
+
+module MARC4J4R
+   
+  class Reader
+
+    ENCODINGS = ['UTF-8', 'ISO-8859-1', 'MARC-8']
+    ENCODING_ALIASES = {:utf8 => 'UTF-8', :marc8 => 'MARC-8', :iso => 'ISO-8859-1'}
+
+    # @attr_reader [File] handle The handle of the File (or IO) object being read from    
+    attr_reader :handle  
+
+  # Get a marc reader of the appropriate type
+  # @param [String, IO, java.io.InputStream] input The IO stream (or filename) from which you want to read
+  # @param [:strictmarc, :permissivemarc, :marcxml] The type of MARC reader you want. 
+  # @param [:utf8, :iso, :marc8, 'UTF-8', 'ISO-8859-1', 'MARC-8'] An explicit encoding
+  # @return [MarcReader] A MarcReader object with the syntactic sugar added in this file (e.g, each)
+  #
+  # @example Get a strict binary MARC reader for the file 'test.mrc'
+  #  reader = MARC4J4R::Reader.new('test.mrc')
+  #  reader = MARC4J4R::Reader.new('test.mrc', :strictmarc) # same thing; :strictmarc is the default
+  # 
+  # @example Get a strict binary MARC reader for the file 'test.mrc', force input to be treated as utf-8
+  #  reader = MARC4J4R::Reader.new('test.mrc', :strictmarc, :utf8)
+  #
+  # @example Get a permissive binary MARC reader
+  #  reader = MARC4J4R::Reader.new('test.mrc', :permissivemarc)
+  #
+  # @example Get a reader for an xml file
+  #  reader = MARC4J4R::Reader.new('test.xml', :marcxml)
+  #
+  # @example Get a reader based on an existing IO object
+  #   require 'open-uri'
+  #   infile = open('http://my.machine.com/test.mrc')
+  #   reader = MARC4J4R::Reader.new(infile)
+
+    def self.new(input, type = :strictmarc, encoding = nil)
+      if encoding
+        encoding = ENCODING_ALIASES[encoding] if ENCODING_ALIASES[encoding]
+        unless ENCODINGS.include? encoding
+          raise ArgumentError, "Encoding must be in [#{ENCODINGS.map {|x| '"' + x + '"'}.join(', ')}], not \"#{encoding}\""
+        end
+      end
+      @handle = IOConvert.byteinstream(input)
+      case type
+      when :strictmarc then
+        Java::org.marc4j.MarcStreamReader.send(:include, Enumerable)
+        return Java::org.marc4j.MarcStreamReader.new(@handle, encoding)
+      when :permissivemarc then
+        encoding ||= 'BESTGUESS'
+        Java::org.marc4j.MarcPermissiveStreamReader.send(:include, Enumerable)
+        Java::org.marc4j.MarcPermissiveStreamReader.send(:include, JLogger::Simple)
+        Java::org.marc4j.MarcPermissiveStreamReader.send(:include, MarcReader::LoggingNextRecord)        
+        return Java::org.marc4j.MarcPermissiveStreamReader.new(@handle, true, true, encoding)
+      when :marcxml then
+        Java::org.marc4j.MarcXmlReader.send(:include, Enumerable)
+        Java::org.marc4j.MarcXmlReader.send(:include, JLogger::Simple)
+        return Java::org.marc4j.MarcXmlReader.new(@handle)
+      when :alephsequential then
+        Java::org.marc4j.MarcAlephSequentialReader.send(:include, Enumerable)
+        Java::org.marc4j.MarcAlephSequentialReader.send(:include, JLogger::Simple)
+        Java::org.marc4j.MarcAlephSequentialReader.send(:include, MarcReader::LoggingNextRecord)
+        return Java::org.marc4j.MarcAlephSequentialReader.new(@handle)
+      when :json then
+        Java::org.marc4j.MarcJsonReader.send(:include, Enumerable)
+        Java::org.marc4j.MarcJsonReader.send(:include, JLogger::Simple)
+        return Java::org.marc4j.MarcJsonReader.new(@handle)
+      else
+        raise ArgumentError, "Reader type #{type} illegal:  must be :strictmarc, :permissivemarc, :marcxml, or :alephsequential"
+      end
+    end
+  end
+end

data/lib/marc4j4r/record.rb

@@ -0,0 +1,257 @@
+require 'stringio'
+module MARC4J4R
+  Record =  Java::org.marc4j.marc.impl::RecordImpl
+
+  class Record
+    include Enumerable
+
+    alias_method :<<, :addVariableField
+    alias_method :append, :addVariableField
+    alias_method :fields, :getVariableFields
+
+    # Export as a MARC-Hash, as described at 
+    # http://robotlibrarian.billdueber.com/marc-hash-the-saga-continues-now-with-even-less-structure/
+    # @return A marc-hash representation of the record, suitable for calling .to_json on or whatever
+
+    # Show equality
+    
+    def == other
+      return false unless (self.leader == other.leader)
+      self.zip(other) do |so|
+        unless so[0] == so[1]
+          puts "self <> other\n#{so[0]}\n#{so[1]}"
+          return false;
+        end
+      end
+      other.zip(self) do |so|
+        unless so[0] == so[1]
+          puts "#{so[0]}\n#{so[1]}"
+          return false;
+        end
+      end      
+      return true
+    end
+
+
+    # Create a local hash by tag number; makes some stuff faster
+    # Called automatically if you use reader.each
+
+    def hashify 
+      return if @hashedtags # don't do it more than once
+      @hashedtags = {}
+      self.getVariableFields.each do |f|
+        @hashedtags[f.tag] ||= []
+        @hashedtags[f.tag].push f
+      end
+    end
+
+    # Force a re-hash
+    def rehash
+      @hashedtags = nil
+      hashify
+    end
+
+    # Create a nice string of the record
+    def to_s
+      arr = ['LEADER ' + self.leader]
+      self.each do |f|
+        arr.push f.to_s
+      end
+      return arr.join("\n")
+    end
+
+    # Get the leader as a string (marc4j would otherwise return Leader object)
+    def leader
+      self.get_leader.toString
+    end
+
+    # Set the leader
+    # @throw RuntimeError if leader is illegal
+    def leader= str
+      begin
+        self.set_leader Java::org.marc4j.marc.impl.LeaderImpl.new(str)
+      rescue Java::java.lang.StringIndexOutOfBoundsException => e
+        raise RuntimeError.new("'#{str}' not a legal leader: #{e.message}")
+      end
+    end
+
+    # Cycle through the fields in the order they appear in the record
+    def each(&blk)
+      self.getVariableFields.each(&blk)
+    end
+
+    # Get the first field associated with a tag
+    # @param [String] tag The tag
+    # @return [Field] The first matching field, or nil if none. Note that
+    # to mirror ruby-marc, this returns a single field 
+
+    def [] tag
+      if defined? @hashedtags
+        if @hashedtags[tag]
+          return @hashedtags[tag][0]
+        else 
+          return nil
+        end
+      else    
+        return self.getVariableField(tag)
+      end
+    end
+
+
+    # Get a (possibly empty) list of fields with the given tag(s)
+    #
+    # @param [String, Array<String>] tags A string (or Array of strings) with the tags you're interested in
+    # @param [Boolean] originalorder Whether or not results should be presented in the original order within the
+    # record or with a two-column sort of (a) Order of the tag in the list of tags sent, (b) order within that tag
+    # in the record
+    # @return [Array<Field>] Either an empty list or a list of one or more matched fields will be returned. 
+    #
+    # originalorder == false will use an internal hash and be faster in many cases (see #hashify)
+    #
+    # @example originalorder == false
+    #  # Given a record that looks like 
+    #  # 010    $a 68027371 
+    #  # 035    $a (RLIN)MIUG0001728-B 
+    #  # 035    $a (CaOTULAS)159818044 
+    #  # 035    $a (OCoLC)ocm00001728
+    #
+    #  r.find_by_tag(['035', '010']).each {|f| puts f.to_s}
+    #  # 035    $a (RLIN)MIUG0001728-B 
+    #  # 035    $a (CaOTULAS)159818044 
+    #  # 035    $a (OCoLC)ocm00001728
+    #  # 010    $a 68027371 
+    #
+    # # The results are ordered first by tag as passed in, then by original order within the tag
+    #
+    # @example Just get all fields for a single tag
+    #  ohThirtyFives = r.find_by_tag('035')
+    #
+    # @example Get a bunch of standard identifiers
+    #   standardIDs = r.find_by_tag(['022', '020', '010'])
+    #
+    # @example originalorder == true
+    #  r.find_by_tag(['035', '010'], true).each {|f| puts f.to_s}
+    #  # 010    $a 68027371 
+    #  # 035    $a (RLIN)MIUG0001728-B 
+    #  # 035    $a (CaOTULAS)159818044 
+    #  # 035    $a (OCoLC)ocm00001728
+
+    def find_by_tag(tags, originalorder = false)
+      self.hashify unless @hashedtags and !originalorder
+      if !tags.is_a? Array
+        return @hashedtags[tags] || []
+      end
+      if originalorder
+        return self.find_all {|f| tags.include? f.tag}
+      else
+        # puts "Tags is #{tags}: got #{@hashedtags.values_at(*tags)}"
+        return @hashedtags.values_at(*tags).flatten.compact
+      end
+    end
+
+
+
+    # Return the record as valid MARC-XML
+    # @param String encoding The encoding to use
+    # @return String A MARC-XML representation of the record, including the XML header
+     
+    def to_xml
+      return Java::org.marc4j.MarcXmlWriter.record_to_XML(self)
+    end
+      
+
+    def to_marc encoding='UTF-8'
+      # begin
+        s = Java::java.io.ByteArrayOutputStream.new
+        writer =  org.marc4j.MarcPermissiveStreamWriter.new(s, encoding)
+        writer.write(self)
+        return s.to_string
+        # writer.close
+        # @marcbinary = s.to_string
+        # return @marcbinary
+      # rescue
+      #   # "Woops! to_marc failed for record #{self['001'].data}: #{$!}"
+      #   "Whoops! Failed: #{$!}"
+      # end
+    end
+  
+    def to_marchash
+      h = {}
+      h['type'] = 'marc-hash'
+      h['version'] = [1,0]
+      h['leader'] = self.leader
+
+      fields = []
+
+      self.getVariableFields.each do |f|
+        if f.controlField?
+          fields << [f.tag, f.value]
+        else 
+          farray = [f.tag, f.indicator1 || ' ', f.indicator2 || ' ']
+          subs = []
+          f.each do |subfield|
+            subs << [subfield.code, subfield.value]
+          end
+          farray.push subs
+          fields << farray
+        end
+      end
+      h['fields'] = fields
+      return h
+    end
+
+    # Turn it into a marc-in-json hashmap. Note that this won't really work
+    # like a ruby hash; you need to know what you're getting, since stuff
+    # like #each won't work.
+    #
+    # Better to just use to_marc_in_json if you want a json string
+
+    def to_hash
+      return Java::org.marc4j.MarcInJSON.record_to_hash(self)
+    end
+
+
+    # Turn it into a marc-in-json JSON string using Jackson
+    def to_marc_in_json
+      return Java::org.marc4j.MarcInJSON.record_to_marc_in_json(self)
+    end
+  
+  
+  end
+    
+  
+
+  # Give a marc record in a string, turn it into an object
+  # @param String str The record as a MARC binary string
+  # @return MARC4J4R::Record The first record encoded in the string
+  #
+  # Note that the normal way of defining this class (self.from_string)
+  # didn't work; I assume it has something to do with the fact that
+  # it's actually jrst aliased to the Java class
+  def Record.from_string str, encoding=nil
+    s = Java::java.io.ByteArrayInputStream.new(str.to_java_bytes)
+    # return MARC4J4R::Reader.new(StringIO.new(str), :strictmarc, encoding).first
+    return MARC4J4R::Reader.new(s, :strictmarc, encoding).first
+  end
+  
+  
+  # Give a marc-xml record in a string, turn it into an object
+  # @param String str The record as a MARC-XML string
+  # @return MARC4J4R::Record The first record encoded in the string
+  def Record.from_xml_string str
+    return MARC4J4R::Reader.new(StringIO.new(str), :marcxml).first
+  end
+  
+  def Record.new_from_hash hash
+    return Java::org.marc4j.MarcInJSON.new_from_hash(hash)
+  end
+  
+  def Record.new_from_marc_in_json jsonstring
+    return Java::org.marc4j.MarcInJSON.new_from_marc_in_json(jsonstring)
+  end
+  
+  
+  
+
+end
+

data/lib/marc4j4r/version.rb

@@ -0,0 +1,4 @@
+module MARC4J4R
+  # marc4j4r version
+  VERSION = "1.4.3"
+end

data/lib/marc4j4r/writer.rb

@@ -0,0 +1,34 @@
+module MARC4J4R
+  # Add some sugar to the MarcWriter interface
+  #
+  # Adjust the interface so that a #new call to any implementations that
+  # implement it can take a java.io.InputStream, ruby IO object, or String
+  # (that will be interpreted as a filename) without complaining.
+  #
+  # The mechanism -- running module_eval on a string-representation of the 
+  # new method in each of the hard-coded implementations -- is ugly
+  # and deeply unsettling.
+  #
+  # @author Bill Dueber
+  #
+
+  class Writer
+  
+    # A simple factory to return the correct type of writer
+    def self.new output, type = :strictmarc
+      @handle = IOConvert.byteoutstream(output)
+      if type == :strictmarc
+        return Java::org.marc4j.MarcStreamWriter.new(@handle)
+      elsif type == :marcxml
+        writer =  Java::org.marc4j.MarcXmlWriter.new(@handle)
+        writer.setUnicodeNormalization(true)
+        return writer
+      elsif type == :json
+        writer = Java::org.marc4j.MarcJsonWriter.new(@handle)
+        return writer
+      else
+        raise ArgumentError.new("#{type} must be :strictmarc, :marcxml, or :json")
+      end
+    end
+  end
+end

data/marc4j4r.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/marc4j4r/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "marc4j4r"
+  gem.platform      = 'java'
+  gem.version       = MARC4J4R::VERSION
+  gem.summary       = %q{A minimal jruby wrapper around marc4j (http://marc4j.tigris.com)}
+  gem.description   = %q{Syntactic sugar and some extra methods to deal with MARC data using a fork of the excellent java library marc4j}
+  gem.license       = "MIT"
+  gem.authors       = ["Bill Dueber"]
+  gem.email         = "bill@dueber.com"
+  gem.homepage      = "https://github.com/billdueber/marc4j4r#readme"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+end