marc4j4r 1.4.3-java

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+doc/
+pkg/
+vendor/cache/*.gem

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "marc4j4r Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,40 @@
+###1.4.3 (2012-12-05)
+  * NOTE: Will not work with jruby 1.6.8 or 1.7.0 because of bug [JRUBY-6581](http://jira.codehaus.org/browse/JRUBY-6581)
+    Better to use 1.6.7 in --1.8 mode or (better) 1.7.1
+  * Switched build system to just use Bundler.
+  * Require writer by default
+  * switched testing framework to minitest
+  * updated to work with jruby 1.7.1
+
+###1.4.2
+  * Allow Aleph control field 'FMT'
+
+###1.4.1
+  * Set so documents without an id are skipped (not indexed)
+
+###1.4.0
+  * Update to use newest version of marc4j_extra_readers_writers.jar; before I wasn't 
+    correctly turning '^' into ' ' in leaders and control fields.
+  
+###1.3.0
+  * Updated to use jlogger; added logging #nextRecord (also used by #each) to 
+    AlephSequentialReader and PermissiveStreamReader
+  
+###1.2.0
+  * Fixed encoding problem with to_marc and from_string roundtrip
+  * Added to_hash/to_marc_in_json and from_hash/from_marc_in_json (see 
+    http://dilettantes.code4lib.org/blog/2010/09/a-proposal-to-serialize-marc-in-json/)
+  
+###1.1
+  * Added native java method to turn a record into XML (20% speedup or so)
+###1.0
+  *  Arbitrary decision that this is 1.0
+  * Using javamarc.jar (fork of marc4j) from http://github.com/billdueber/javamarc
+  * Including alephsequential reader (but not writer) and specs
+  * Added code to Reader#each to deal with #errors object if provided by the
+    specific reader (right now, :permissivemarc and :alephsequential) and specs
+    to test
+  * Updated to latest marc4j; changes involve character conversion
+
+### 0.9.0
+  * First real public release

data/Gemfile

@@ -0,0 +1,16 @@
+source :rubygems
+
+gem 'jlogger'
+
+group :development do
+  gem 'kramdown'
+  gem 'bundler', '~> 1.0'
+  gem 'rake', '~> 10'
+  gem 'yard', '~> 0.8'
+end
+
+group :test do
+  gem 'minitest', '~> 4'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2012 Bill Dueber
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# marc4j4r
+
+* [Homepage](https://github.com/billdueber/marc4j4r#readme)
+* [Issues](https://github.com/billdueber/marc4j4r/issues)
+* [Documentation](http://rubydoc.info/gems/marc4j4r/frames)
+* [Email](mailto:bill at dueber.com)
+
+
+A ruby wrapper around the marc4j.jar (as forked by javamarc) java library for dealing with library MARC data.
+
+## JRuby version alert
+
+`MARC4J4R::Record#each` throws an error in JRuby versions bfore 1.7.1 when in --1.9 mode  Your best bet is to use JRuby 1.7.1 (or higher).
+[The error in question is, I think [JRUBY-6581](https://jira.codehaus.org/browse/JRUBY-6581)]
+
+## Deprecation alert
+
+I'm giving up on this standalone module and focusing my efforts into making
+a marc4j add-on for the standard [ruby-marc](https://github.com/ruby-marc/ruby-marc) distribution.
+
+
+## Getting a MARC reader
+
+marc4j4r provides three readers out of the box: :strictmarc (binary), :permissivemarc (:binary), :marcxml (MARC-XML), 
+or :alephsequential (Ex Libris's AlephSequential format).
+
+You can pass either a filename or an open IO object (either ruby or java.io.inputstream)
+
+    require 'marc4j4r'
+  
+    binreader = MARC4J4R::Reader.new('test.mrc') # defaults to :strictmarc
+    binreader = MARC4J4R::Reader.new('test.mrc', :strictmarc)
+  
+    permissivereader =  MARC4J4R::Reader.new('test.mrc', :permissivemarc)
+
+    xmlreader = MARC4J4R::Reader.new('test.xml', :marcxml)
+    asreader = MARC4J4R::Reader.new('test.seq', :alephsequential)
+  
+    # Or use a file object
+  
+    reader = MARC4J4R::Reader.new(File.open('test.mrc'))
+    
+    # Or a java.io.inputstream
+  
+    jurl = Java::java.net.URL.new('http://my.machine.com/test.mrc')
+    istream = jurl.openConnection.getInputStream
+    reader = MARC4J4R::Reader.new(istream)
+
+## Using the reader
+
+A MARC4J4R::Reader is an Enumerable, so you can do:
+
+    reader.each do |record|
+      # do stuff with the record
+    end
+
+Or, if you're using [jruby_threach](http://rdoc.info/projects/billdueber/jruby_threach):
+
+    reader.threach(2) do |record|
+      # do stuff with records in two threads
+    end
+  
+## Using the writer
+
+
+      binaryWriter = MARC4J4R::Writer.new(filename, :strictmarc)
+      xmlWriter    = MARC4J4R::Writer.new(filename, :marcxml)
+  
+      writer.write(record)
+      # repeat
+      writer.close
+
+
+## Working with records and fields
+
+In addition to all the normal marc4j methods, MARC4J4R::Record exposes some additional methods
+and syntaxes. 
+
+See the classes themselves and/or the specs for more examples.
+
+* {MARC4J4R::Reader}
+* {MARC4J4R::Writer}
+* {MARC4J4R::Record}
+* {MARC4J4R::ControlField}
+* {MARC4J4R::DataField}
+* {MARC4J4R::SubField}
+
+
+     leader = record.leader
+
+     # All fields are available via #each or #fields
+   
+     fields = record.fields
+
+     record.each do |field|
+       # do something with each controlfield/datafield; returned in the order they were added
+     end
+   
+     # Controlfields have a tag and a value
+
+     idfield = record['001']
+     idfield.tag # => '001'
+     id = idfield.value # or idfield.data, same thing
+   
+     # Get the first datafield with a given tag
+     first700 = record['700'] # Note: need to use strings, not integers
+   
+     # Stringify a field to get all the subfields joined with spaces
+   
+     fullTitle = record['245'].to_s
+   
+     all700s  = record.find_by_tag '700'
+     all700and856s = record.find_by_tag ['700', '856']
+
+   
+     # Construct and add a controlfield
+     record << MARC4J4R::ControlField.new('001', '0000333234')
+   
+     # Construct and add a datafield
+     df = MARC4J4R::DataField.new(tag, ind1, ind2)
+   
+     ind1 = df.ind1
+     ind2 = df.ind2
+   
+     df << MARC4J4R::Subfield.new('a', 'the $a value')
+     df << MARC4J4R::Subfield.new('b', 'the $b value')   
+   
+     # Add it to a record
+   
+     record << df
+   
+     # Get subfields or their values
+   
+     firstSubfieldAValue = df['a']
+   
+     allSubfields = df.subs
+     allSubfieldAs = df.subs('a')
+     allSubfieldAorBs = df.subs(['a', 'b'])
+   
+     allSubfieldAorBValues = df.sub_values(['a', 'b'])
+
+
+
+## Install
+
+   $ gem install marc4j4r
+
+
+## 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) 2012 Bill Dueber
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require "bundler/gem_tasks"
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require 'rake/testtask'
+Rake::TestTask.new do |test|
+  test.libs << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end

data/lib/marc4j4r.rb

@@ -0,0 +1,73 @@
+require 'marc4j4r/version'
+
+unless defined? JRUBY_VERSION
+  raise "Only works under JRUBY"
+end
+
+jardir = File.join(File.dirname(__FILE__), '..', 'jars')
+
+# For each jar, check for a representative class in each
+# and include the jar if it's not defined
+
+begin
+  java_import Java::org.marc4j.marc.impl.RecordImpl
+rescue NameError  => e
+  require "#{jardir}/javamarc.jar"
+end
+
+begin
+  java_import Java::org.marc4j.MarcAlephSequentialReader
+rescue
+  require "#{jardir}/marc4j-extra-readers-writers.jar"
+end
+
+begin
+  java_import Java::org.codehaus.jackson.map.ObjectMapper
+rescue
+  require "#{jardir}/jackson-all-1.6.0.jar"
+end
+
+
+# Define a method that will take a string (filename), IO object, or StringIO object,
+# and return an inputstream/outputstream
+
+module IOConvert
+  
+  def byteinstream(fromwhere)
+    stream = nil
+    if fromwhere.is_a? Java::JavaIO::InputStream
+      stream = fromwhere
+    elsif fromwhere.is_a? String
+      stream = java.io.FileInputStream.new(fromwhere.to_java_string)
+    elsif fromwhere.respond_to? :to_inputstream
+      stream = fromwhere.to_inputstream
+    end
+    return stream
+  end
+  
+  def byteoutstream towhere
+    stream = nil
+    if towhere.is_a? Java::JavaIO::OutputStream
+      stream = towhere
+    elsif towhere.is_a? String
+      stream = java.io.FileOutputStream.new(towhere.to_java_string)
+    elsif towhere.respond_to? :to_outputstream
+      stream = towhere.to_outputstream
+    end
+    return stream
+  end
+  
+  
+  module_function :byteinstream, :byteoutstream
+  
+end
+  
+  
+  
+  
+
+require 'marc4j4r/record.rb'
+require 'marc4j4r/controlfield.rb'
+require 'marc4j4r/reader.rb'
+require 'marc4j4r/datafield.rb'
+require 'marc4j4r/writer.rb'

data/lib/marc4j4r/controlfield.rb

@@ -0,0 +1,34 @@
+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 true if Java::org.marc4j.marc.impl.Verifier.isControlField(tag)
+      return true if tag == 'FMT'
+      return false
+    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,195 @@
+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
+      
+      return false if selfsubs.size != othersubs.size
+      
+      # 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