marc4j4r 0.2.2 → 0.2.4

data/README.markdown

@@ -0,0 +1,128 @@
+# marc4j4r
+
+A ruby wrapper around the marc4j.jar (as forked by javamarc) java library for dealing with library MARC data.
+
+## Getting a MARC reader
+
+marc4j4r provides three readers out of the box: :strictmarc (binary), :permissivemarc (:binary), and :marcxml (MARC-XML).
+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)
+  
+    # 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 [threach](http://rdoc.info/projects/billdueber/threach):
+
+    reader.threach(2) do |record|
+      # do stuff with records in two threads
+    end
+  
+## Using the writer
+
+The writer code has not yet been tested; it *should* work as follows:
+
+      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.**
+
+     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'])
+
+
+## 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

@@ -13,6 +13,7 @@ begin
     gem.authors = ["BillDueber"]
     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
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.4

data/lib/marc4j4r/datafield.rb

@@ -95,7 +95,7 @@ module MARC4J4R
         code = [code]
       end
       
-      return self.grep {|s| code.include? s.code}
+      return self.select {|s| code.include? s.code}
     end
     
     # Get all values from the subfields for the given code or array of codes
@@ -110,7 +110,7 @@ module MARC4J4R
     # rec['260'].sub_values(['a', 'c']) #=> ["New York,", "1969"]
     # rec['260'].sub_values(['c', 'a']) #=> ["New York,", "1969"]
 
-    def sub_values(code)
+    def sub_values(code=nil)
       return self.subs(code).collect {|s| s.value}
     end
 

metadata

@@ -1,46 +1,51 @@
 --- !ruby/object:Gem::Specification 
 name: marc4j4r
 version: !ruby/object:Gem::Version 
+  hash: 31
   prerelease: false
   segments: 
-    - 0
-    - 2
-    - 2
-  version: 0.2.2
+  - 0
+  - 2
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
-  - BillDueber
+- BillDueber
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-07-13 00:00:00 -04:00
+date: 2010-07-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: bacon
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: yard
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :development
-    version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: Syntactic sugar and some extra methods to deal with MARC data using the java .jar marc4j
 email: bill@dueber.com
 executables: []
@@ -50,56 +55,59 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-  - LICENSE
-  - README.rdoc
-  - Rakefile
-  - VERSION
-  - jars/marc4j.jar
-  - lib/marc4j4r.rb
-  - lib/marc4j4r/controlfield.rb
-  - lib/marc4j4r/datafield.rb
-  - lib/marc4j4r/reader.rb
-  - lib/marc4j4r/record.rb
-  - lib/marc4j4r/writer.rb
-  - lib/original_monolithic_file.rb
-  - spec/batch.dat
-  - spec/batch.txt
-  - spec/batch.xml
-  - spec/controlfield_spec.rb
-  - spec/datafield_spec.rb
-  - spec/one.dat
-  - spec/one.txt
-  - spec/one.xml
-  - spec/reader_spec.rb
-  - spec/record_spec.rb
-  - spec/spec_helper.rb
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- jars/marc4j.jar
+- lib/marc4j4r.rb
+- lib/marc4j4r/controlfield.rb
+- lib/marc4j4r/datafield.rb
+- lib/marc4j4r/reader.rb
+- lib/marc4j4r/record.rb
+- lib/marc4j4r/writer.rb
+- spec/batch.dat
+- spec/batch.txt
+- spec/batch.xml
+- spec/controlfield_spec.rb
+- spec/datafield_spec.rb
+- spec/one.dat
+- spec/one.txt
+- spec/one.xml
+- spec/reader_spec.rb
+- spec/record_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/billdueber/javamarc/tree/master/ruby/marc4j4r/
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --charset=UTF-8
+- --charset=UTF-8
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Use marc4j java library in JRuby in a more ruby-ish way

data/README.rdoc

@@ -1,17 +0,0 @@
-= 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/lib/original_monolithic_file.rb

@@ -1,518 +0,0 @@
-unless defined? JRUBY_VERSION
-  raise "Only works under JRUBY"
-end
-
-begin
-  include_class Java::org.marc4j.marc.impl.RecordImpl
-rescue NameError  => e
-  jardir = File.join(File.dirname(__FILE__), '..', 'jars')
-  require "#{jardir}/marc4j.jar"
-end
-
-require 'set'
-
-
-# Re-open the MarcReader interface, define #each and include Enumerable
-#
-# We also automatically call #hashify on the records that stream through
-# #each in order to speed up RecordImpl#[] when (a) doing many operations on a single
-# record, and (b) we're not worried about interleaved tags (e.g., a 520 followed by a 510 followed
-# by another 520)
-
-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
-  
-  # Do some simple substitutions to make things prettier. After this,
-  # we can use MARC4J4R::Record instead of Java::org.marc4j.marc.impl::RecordImpl
-  
-  Record =  Java::org.marc4j.marc.impl::RecordImpl
-  ControlField = Java::org.marc4j.marc.impl::ControlFieldImpl
-  DataField = Java::org.marc4j.marc.impl::DataFieldImpl
-  SubField = Java::org.marc4j.marc.impl::SubfieldImpl
-  
-
-  # 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
-  #
-  # A string used to override the initializer for each stream reader
-  # Need to do it this ugly way because of the way java and ruby interact;
-  # can't just add it to the MarcReader interface the way I wanted to.
-  
-  NEWINIT = <<-ENDBINDER
-    include Enumerable
-    alias_method :oldinit, :initialize
-    def initialize(fromwhere)
-      stream = nil
-      if fromwhere.is_a? Java::JavaIO::InputStream or fromwhere.is_a? Java::JavaIO::ByteArrayInputStream
-        stream = fromwhere
-      elsif fromwhere.is_a? IO
-        stream = fromwhere.to_inputstream
-      else
-        stream = java.io.FileInputStream.new(fromwhere.to_java_string)
-      end
-      if self.class == Java::org.marc4j.MarcPermissiveStreamReader
-        self.oldinit(stream, true, true)
-      else
-        self.oldinit(stream)
-      end
-    end
-  ENDBINDER
-
-  Java::org.marc4j.MarcStreamReader.module_eval(NEWINIT)
-  Java::org.marc4j.MarcPermissiveStreamReader.module_eval(NEWINIT)
-  Java::org.marc4j.MarcXmlReader.module_eval(NEWINIT)
-  
-  
-  
-  # 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('test.mrc')
-  #
-  # @example Get a permissive binary MARC reader
-  #  reader = MARC4J4R.reader('test.mrc', :permissivemarc)
-  #
-  # @example Get a reader for an xml file
-  #  reader = MARC4J4R.reader('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(infile)
-  
-  def reader(input, type  = :strictmarc)
-    case type
-    when :strictmarc then
-      return Java::org.marc4j.MarcStreamReader.new(input)
-    when :permissivemarc then
-      return Java::org.marc4j.MarcPermissiveStreamReader.new(input)
-    when :marcxml then
-      return Java::org.marc4j.MarcXmlReader.new(input)
-    when :alephsequential then
-      return MARC4J4R::AlephSequentialReader.new(input)
-    else
-      raise ArgumentError, "Reader type #{type} illegal:  must be :strictmarc, :permissivemarc, :marcxml, or :alephsequential"
-    end
-  end
-  module_function :reader
-  
-  
-  # Implement an AlephSequential reader
-  class AlephSequentialReader
-    include Enumerable
-    def initialize(fromwhere)
-      stream = nil
-      if fromwhere.is_a? Java::JavaIO::InputStream
-        stream = fromwhere.to_io
-      elsif fromwhere.is_a? IO
-        stream = fromwhere
-      else
-        stream = File.new(fromwhere)
-      end
-      
-      @handle = stream
-    end
-  
-    def each
-      record = nil
-      currentID = nil
-      
-      @handle.each_line do |l|
-        l.chomp!
-        next unless l =~ /\S/
-        vals = l.unpack('a9 a a3 c c a3 a*')
-        id, tag, ind1, ind2, data = vals[0], vals[2], vals[3], vals[4], vals[6]
-        # id, tag, ind1, ind2, junk, data = *(l.unpack('A10 a3 c c a3 A*'))
-        if id != currentID
-          if record
-            yield record
-          end
-          record = RecordImpl.new
-          currentID = id
-        end
-        if tag == 'LDR'
-          record.setLeader(Java::org.marc4j.marc.impl.LeaderImpl.new(data))
-        else
-          record << buildField(tag,ind1,ind2,data)
-        end
-      end
-      yield record
-    end
-    
-    
-    SUBREGEXP = /\$\$(.)/
-    def buildField (tag, ind1, ind2, data)
-      if Java::org.marc4j.marc.impl.Verifier.isControlField tag
-        return Java::org.marc4j.marc.impl.ControlFieldImpl.new(tag, data)
-      else
-        f = Java::org.marc4j.marc.impl.DataFieldImpl.new(tag, ind1, ind2)
-        data.split(SUBREGEXP)[1..-1].each_slice(2) do |code, value|
-          f.addSubfield Java::org.marc4j.marc.impl.SubfieldImpl.new(code[0].ord, value)
-        end
-        return f
-      end
-    end
-    
-  end # End of class AlephSequentialReader
-
-end
-
-
-# Open up RecordImpl to add some sugar, including Enumberable as well
-# @author Bill Dueber
-
-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
-  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
-
-  # 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
-  
-  
-  # 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
-    return @xml if @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
-      puts @marcbinary
-      return @marcbinary
-    rescue
-      # "Woops! to_marc failed for record #{self['001'].data}: #{$!}"
-      "Whoops! Failed: #{$!}"
-    end
-  end
-    
-	
-end
-
-class ControlField
-  def value
-    return self.data
-  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
-
-class DataField
-  include Enumerable
-  
-  alias_method :<<, :addSubfield
-  
-  
-  def controlField?
-    return false
-  end
-  
-  # Broken. Need to check subs as well
-  def == other
-    self.tag == other.tag and
-    self.indicator1 == other.indicator1 and
-    self.indicator2 == other.indicator2
-  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
-
-
-  # 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
-  # @param [Boolean] myorder Use the order of subfields that I gave instead of the order they're in the record
-  # @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. If myorder == true, use the order in which they are passed in; if a code is repeated
-  # (ocassionally legal) subfield values will appear first ordered by the passed array, then by order within
-  # the document.
-  #
-  # If myorder is false, just return the values for matching subfields in the order they appear in the field.
-  #
-  # @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"]
-  # rec['260'].sub_values(['c', 'a'], true) #=> ["1969", "New York"]
-  
-  def sub_values(code, myorder = false)
-    
-    # Do a little razzle-dazzle for the common case when a single code is given
-    if not [Set, Array].include? code.class
-      c = code
-    elsif code.size == 1
-      c = code.first
-    end
-    if c
-      return self.find_all { |s| c == s.code}.map {|s| s.data}
-    end
-    
-    # unless [Set, Array].include? code.class
-    #   code = [code] 
-    #   # puts "Arrayified for code #{code} / #{code.class}"
-    # end
-    if myorder
-      subs = []
-      code.each do |c|
-        subs << self.find_all {|s| c == s.code}
-      end
-      return subs.flatten.map {|s| s.data}
-    else
-      return self.find_all{|s| code.include? s.code}.map {|s| s.data}
-    end
-  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
-
-  # 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
-  
-  def == other
-    return ((self.code == other.code) and (self.data == other.data))
-  end
-  
-  def value
-    return self.data
-  end
-  
-  def code
-    return self.getCode.chr
-  end
-
-  def to_s
-    return '$' + self.code + " " + self.data
-  end
-end