marc4j4r 1.4.1 → 1.4.2

data/lib/marc4j4r/datafield.rb

@@ -1,192 +0,0 @@
-module MARC4J4R
-  DataField = Java::org.marc4j.marc.impl::DataFieldImpl
-  SubField = Java::org.marc4j.marc.impl::SubfieldImpl
-  
-  class DataField
-    include Enumerable
-
-    alias_method :<<, :addSubfield
-    alias_method :add, :addSubfield
-
-    # Override the initialize to allow creation with just a tag (marc4j only allows either
-    # no args or the tag and both indicators)
-    
-    alias_method :oldinit, :initialize
-    def initialize(tag = nil, ind1 = ' ', ind2 = ' ')
-      self.oldinit(tag, ind1[0].ord, ind2[0].ord)
-    end
-
-    def controlField?
-      return false
-    end
-
-    def == other
-      
-      basics =  ((self.tag == other.tag) and (self.indicator1 == other.indicator1) and  (self.indicator2 == other.indicator2))
-      unless basics
-        # puts "Failed basics"
-        return false 
-      end
-      selfsubs  = self.to_a
-      othersubs = other.to_a
-      # puts "#{self} vs #{other}"
-      while (selfsubs.length > 0)
-        ssf  = selfsubs.shift
-        osf  = othersubs.shift
-        unless ssf == osf
-          # puts "#{ssf} <> #{osf}"
-          return false 
-        end
-      end
-      
-      if ((selfsubs.size > 0) or (othersubs.size > 0))
-        # puts "sizes unequal"
-        return false 
-      end
-      return true
-    end
-
-    # Pretty-print
-    # @param [String] joiner What string to use to join the subfields
-    # @param [String] The pretty string
-    def to_s (joiner = ' ')
-      arr =  [self.tag + ' ' + self.indicator1 + self.indicator2]
-      self.each do |s|
-        arr.push s.to_s
-      end
-      return arr.join(joiner)
-    end
-    
-
-    # Get the value of the first subfield of this field with the given code
-    # @param [String] code 1-character string of the subfield code
-    # @return [String] The value of the first matched subfield
-    def [] code
-      raise ArgumentError, "Code must be a one-character string, not #{code}" unless code.is_a? String and code.size == 1
-      # need to send a char value that the underlying java can deal with
-      sub = self.getSubfield(code[0].ord)
-      if (sub)
-        return sub.getData
-      else 
-        return nil
-      end
-    end
-
-    # Also call it "sub" for symmatry wtih "sub_values" and "subs"
-    # and "first" because it makes sense
-    alias_method :sub, :[]
-    alias_method :first, :[]
-    
-    # Get all subfields, optionally restricting to those with a given code
-    # @param [String, Array<String>] code A (array of?) 1-character strings; the code(s) to collect. Default is all
-    # @return [Array<MARC4J4R::SubField] The matching subfields, or an empty array
-    
-    def subs code = false
-      unless code
-        return self.to_a
-      end
-      
-      # Is it a singleton?
-      unless code.is_a? Array
-        code = [code]
-      end
-      
-      return self.select {|s| code.include? s.code}
-    end
-    
-    # Get all values from the subfields for the given code or array of codes
-    # @param [String, Array<String>] code (Array of?) 1-character string(s) of the subfield code
-    # @return [Array<String>] A possibly-empty array of Strings made up of the values in the subfields whose
-    # code is included in the given codes (or all subfields is code is empty)
-    #
-    #
-    # @example Quick examples:
-    #  # 260    $a New York, $b Van Nostrand Reinhold Co. $c 1969
-    # rec['260'].sub_values('a') #=> ["New York,"]
-    # rec['260'].sub_values(['a', 'c']) #=> ["New York,", "1969"]
-    # rec['260'].sub_values(['c', 'a']) #=> ["New York,", "1969"]
-
-    def sub_values(code=nil)
-      return self.subs(code).collect {|s| s.value}
-    end
-
- 
-    # Get first indicator as a one-character string
-    def indicator1
-      return self.getIndicator1.chr
-    end
-
-    # Get second indicator as a one-character string
-    def indicator2
-      return self.getIndicator2.chr
-    end
-    
-    def indicator1= char
-      self.setIndicator1 char[0].ord
-    end
-
-    def indicator2= char
-      self.setIndicator2 char[0].ord
-    end
-    
-    alias_method :ind1, :indicator1
-    alias_method :"ind1=", :"indicator1="
-    alias_method :ind2, :indicator2
-    alias_method :"ind2=", :"indicator2="
-
-    # Iterate over the subfields
-    def each
-      self.getSubfields.each do |s|
-        yield s
-      end
-    end
-
-    # Get the concatentated values of the subfields in order the appear in the field
-    # @param [String] joiner The string used to join the subfield values
-    def value joiner=' '
-      data = self.getSubfields.map {|s| s.data}
-      return data.join(joiner)
-    end  
-  end
-
-  class SubField
-    
-    alias_method :oldinit, :initialize
-    def initialize code=nil, data=nil
-      if code
-        code = code[0].ord
-        if data
-          self.oldinit(code, data)
-        else
-          self.oldinit(code)
-        end
-      else
-        self.oldinit
-      end
-    end
-
-    def == other
-      return ((self.code == other.code) and (self.data == other.data))
-    end
-
-    def value
-      return self.data
-    end
-    
-    def value= str
-      self.data = str
-    end
-    
-    def code
-      return self.getCode.chr
-    end
-    
-    def code= str
-      self.setCode str[0].ord
-    end
-
-    def to_s
-      return '$' + self.code + " " + self.data
-    end
-  end
-end  

data/lib/marc4j4r/reader.rb

@@ -1,125 +0,0 @@
-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)
-      else
-        raise ArgumentError, "Reader type #{type} illegal:  must be :strictmarc, :permissivemarc, :marcxml, or :alephsequential"
-      end
-    end
-  end
-end

data/lib/marc4j4r/record.rb

@@ -1,259 +0,0 @@
-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 the appear in the record
-    def each
-      self.getVariableFields.each do |f|
-        yield f
-      end
-    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
-