marc4j4r 0.1.6 → 0.2.2

data/README.rdoc

@@ -0,0 +1,17 @@
+= marc4j4r
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 BillDueber. See LICENSE for details.

data/Rakefile

@@ -1,16 +1,17 @@
 require 'rubygems'
 require 'rake'
+require 'ftools'
 
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "marc4j4r"
     gem.summary = %Q{Use marc4j java library in JRuby in a more ruby-ish way}
-    gem.description = %Q{Syntactic sugar and some extra methods to deal with classes in the marc4j java package}
+    gem.description = %Q{Syntactic sugar and some extra methods to deal with MARC data using the java .jar marc4j}
     gem.email = "bill@dueber.com"
-    gem.homepage = "http://github.com/billdueber/marc4j4r"
+    gem.homepage = "http://github.com/billdueber/javamarc/tree/master/ruby/marc4j4r/"
     gem.authors = ["BillDueber"]
-    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "bacon", ">= 0"
     gem.add_development_dependency "yard", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
@@ -19,19 +20,31 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
+
+# Make sure we've got the right .jar
+LOCALJAR = 'jars/marc4j.jar'
+JAVAJAR  = '../../marc4j.jar'
+
+
+file LOCALJAR => JAVAJAR do |t|
+  File.copy(JAVAJAR, LOCALJAR)
+end
+  
+
+
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
 end
 
 begin
   require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
   end
 rescue LoadError
   task :rcov do
@@ -39,9 +52,9 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
+task :spec => [:check_dependencies, LOCALJAR]
 
-task :default => :test
+task :default => :spec
 
 begin
   require 'yard'

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.2

data/lib/marc4j4r/controlfield.rb

@@ -0,0 +1,32 @@
+module MARC4J4R
+  ControlField = Java::org.marc4j.marc.impl::ControlFieldImpl
+  class ControlField
+    def value
+      return self.data
+    end
+
+    def value= str
+      self.data = str
+    end
+
+    def controlField?
+      return true
+    end 
+
+    def self.control_tag? tag
+      return Java::org.marc4j.marc.impl.Verifier.isControlField tag
+    end
+
+    # Pretty-print
+    # @param [String] joiner What string to use to join the subfields
+    # @param [String] The pretty string
+    def to_s
+      return self.tag + "    " + self.value
+    end
+
+    def == other
+      self.tag == other.tag && self.value == other.value
+    end
+
+  end
+end

data/lib/marc4j4r/datafield.rb

@@ -0,0 +1,196 @@
+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 = ' ')
+      if tag
+        self.oldinit(tag, ind1[0].ord, ind2[0].ord)
+      else 
+        self.oldinit
+      end
+    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?
+      if not [Set, Array].include? code.class
+        code = [code]
+      end
+      
+      return self.grep {|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)
+      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

@@ -0,0 +1,71 @@
+module Java::OrgMarc4j::MarcReader
+  include Enumerable
+  
+  # Return the next record, after calling #hashify on it
+  def each(hashify=true)
+    while self.hasNext
+      r = self.next
+      r.hashify if hashify
+      yield r
+    end
+  end  
+end
+
+
+module MARC4J4R
+  # Add some sugar to the MarcReader interface
+  #
+  # Adjust the interface so that a #new call to any implementations that
+  # implement it can take a java.io.InputStream, ruby IO obejct, 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 of MarcReader
+  # (MarcStreamReader,MarcPermissiveStreamReader,MarcXmlReader) -- is ugly
+  # and deeply unsettling.
+  #
+  # @author Bill Dueber
+
+  # First, add Enumerable to the interface  
+  Java::org.marc4j.MarcReader.module_eval("include Enumerable")
+  
+  
+  class Reader
+      
+  # 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. 
+  # @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')
+  #
+  # @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)
+
+    attr_reader :handle  
+    def self.new(input, type = :strictmarc)
+      @handle = IOConvert.byteinstream(input)
+      case type
+      when :strictmarc then
+        return Java::org.marc4j.MarcStreamReader.new(@handle)
+      when :permissivemarc then
+        return Java::org.marc4j.MarcPermissiveStreamReader.new(@handle, true, true)
+      when :marcxml then
+        return Java::org.marc4j.MarcXmlReader.new(@handle)
+      when :alephsequential then
+        return MARC4J4R::AlephSequentialReader.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,214 @@
+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|
+        return false unless so[0] == so[1]
+      end
+      other.zip(self) do |so|
+        return false unless so[0] == so[1]
+      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
+
+    # 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
+    def leader= str
+      begin
+        self.set_leader Java::org.marc4j.marc.impl.LeaderImpl.new(str)
+      rescue java.lang.StringIndexOutOfBoundsException => e
+        throw 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
+    # @return String A MARC-XML representation of the record, including the XML header
+    def to_xml
+      begin
+        xml = java.io.StringWriter.new
+        res = javax.xml.transform.stream.StreamResult.new(xml)
+        writer =  org.marc4j.MarcXmlWriter.new(res)
+        writer.write(self)
+        writer.writeEndDocument
+        return xml.toString
+      rescue
+        "Woops! to_xml failed for record #{self['001'].data}: #{$!}"
+      end
+  	end
+
+  	def to_marc
+      begin
+        s = Java::java.io.ByteArrayOutputStream.new
+        writer =  org.marc4j.MarcStreamWriter.new(s)
+        writer.write(self)
+        @marcbinary = s.to_string
+        return @marcbinary
+      rescue
+        # "Woops! to_marc failed for record #{self['001'].data}: #{$!}"
+        "Whoops! Failed: #{$!}"
+      end
+    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
+
+  # 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
+  def self.from_string str
+    return MARC4J4R::Reader.new(StringIO.new(str)).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 self.from_xml_string str
+    return MARC4J4R::Reader.new(StringIO.new(str), :marcxml).first
+  end
+  
+
+end
+

data/lib/marc4j4r/writer.rb

@@ -0,0 +1,29 @@
+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
+        return Java::org.marc4j.MarcStreamWriter.new(@handle)
+      else
+        raise ArgumentError.new("#{type} must be :strictmarc or :marcxml")
+      end
+    end
+  end
+end