marcspec 0.6.0 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/lib/marcspec/controlfieldspec.rb

@@ -0,0 +1,93 @@
+require 'marc4j4r'
+require 'set'
+require 'pp'
+module MARCSpec
+  # A ControlFieldSpec takes a control tag (generally 001..009) and an optional zero-based range
+  # When called with marc_values(record), it returns either the complete value of all
+  # occurances of the field in question (in the order they appear in the record), or 
+  # the zero-based substrings based on the passed range. 
+  #
+  # @example Get the whole 001
+  # cfs = MARCSpec::ControlTagSpec.new('001')
+  # 
+  # @example Get the first three characters of the 008
+  # cfs = MARCSpec::ControlTagSpec.new('001', 0..2)
+  #
+  # Note that the use of the zero-based range in this manner conforms to the way MARC 
+  # substrings are specified.
+  
+  class ControlFieldSpec
+    attr_accessor :tag, :range
+    
+    def initialize (tag, range=nil)
+      unless MARC4J4R::ControlField.control_tag? tag
+        raise ArgumentError "Tag must be a control tag"
+      end
+      @tag = tag
+      self.range = range
+    end
+    
+    def == other
+      return ((self.tag == other.tag) and
+              (self.range = other.range))
+    end
+    
+    
+    # Always force a real range, since in Ruby 1.9 a string subscript with a single fixnum
+    # will return the character code of that character (e.g., "Bill"[0] => 66, wherease 
+    # "Bill"[0..0] gives the expected 'B'
+    #
+    # @param [nil, Fixnum, Range] range A zero-based substring range or character position
+    # @return [MARCSpec::ControlFieldSpec] self
+    
+    def range= range
+      if range.nil?
+        @range = nil
+        return self
+      end
+      if range.is_a? Fixnum
+        if range < 0
+          raise ArgumentError, "Range must be nil, an integer offset (1-based), or a Range, not #{range}"
+        end
+      
+        @range = range..range
+      
+      elsif range.is_a? Range
+        @range = range
+      else
+        raise ArgumentError, "Range must be nil, an integer offset (1-based), or a Range, not #{range.inspect}"
+      end
+      return self
+    end
+    
+    
+    def marc_values r
+      vals = r.find_by_tag(@tag).map {|f| f.value}
+      if @range
+        return vals.map {|v| v[@range]}
+      else
+        return vals
+      end
+    end
+    
+    def pretty_print pp
+      pp.pp eval(self.asPPString)
+    end
+    
+    def asPPString
+      s = StringIO.new
+      if @range
+        PP.pp([@tag, @range], s)
+      else
+        PP.pp([@tag], s)
+      end
+      return s.string
+    end
+    
+    def self.fromPPString str
+      a = eval(str)
+      return self.new(*a)
+    end
+    
+  end
+end

data/lib/marcspec/customspec.rb

@@ -5,10 +5,12 @@ require 'marcspec/solrfieldspec'
 module MARCSpec
 
   # A CustomSolrSpec is a SolrFieldSpec that derives all its values from a custom function. The custom function
-  # must me a module function that takes a record and an array of other arguments and returns a 
+  # must me a module function that takes a hash-like document object, a MARC4J4R record, and an array of other arguments and returns a 
   # (possibly empty) list of resulting values.
   #
-  # @example
+  # See the example file simple_sample/index.rb in the marc2solr project for configuration examples.
+  #
+  # @example A sample custom function, to be placed in the configuration directory's lib/ subdir
   #  module MARC2Solr
   #   module MyCustomStuff
   #     def self.uppercaseTitle r, args=[]
@@ -19,25 +21,40 @@ module MARCSpec
   #   end
   # end
   #
+  # @example A simple custom spec made by hand
   # css = MARCSpec::CustomSolrSpec.new(:module => MARC2Solr::MyCustomStuff,
-  #                                    :methodSymbol => :uppercaseTitle,
+  #                                    :functionSymbol => :uppercaseTitle,
   #                                    :map => ss.map('mapname')
   #                                   )
-  # ss.add_spec(css)
   #
   # 
   
 
   class CustomSolrSpec < SolrFieldSpec
     
-    attr_accessor :module, :methodSymbol, :methodArgs
+    attr_accessor :module, :functionSymbol, :methodArgs
+    
+    # Get a new Custom Solr Spec based on the passed in options. 
+    # @param [Hash] opts Initialization options
+    # @option opts [String, Array<String>] :solrField the name(s) of the Solr field(s) that will receive the data derived from this spec
+    # @option opts [Module] :module the actual module constant (not a string or symbol representation) which holds the 
+    # custom function we'll be calling
+    # @option opts [Symbol] :functionSymbol A symbol of the name of the custom function
+    # @option opts [Boolean] :firstOnly (false) Whether we should return the first found value
+    # @option opts [String] :default (nil) The value to return if the custom function returns no values
+    # @option opts [MARC2Solr::Map] :map (nil) An optional Map used to translate resulting values
+    # @option opts [String] :noMapKeyDefault (nil) The value to return if (a) a value is found, (b) a map is defined, but (c) there's
+    # no key in the map that matches the value. 
+    #
+    # Note that the last four options don't make sense if multiple :solrFields are given, and are illegal in that case.
+    
     def initialize(opts)
       @solrField  = opts[:solrField]
       @module = opts[:module]
-      @methodSymbol = opts[:methodSymbol]
+      @functionSymbol = opts[:functionSymbol]
 
-      unless @solrField and @module and @methodSymbol
-        raise ArgumentError, "Custom solr spec must have a field name in :solrField, module in :module, and the method name as a symbol in :methodSymbol"
+      unless @solrField and @module and @functionSymbol
+        raise ArgumentError, "Custom solr spec must have a field name in :solrField, module in :module, and the method name as a symbol in :functionSymbol"
       end
       
       
@@ -60,11 +77,19 @@ module MARCSpec
       
     end
     
+    # Get values from a MARC object and/or the prevously-filled document object.
+    #
+    # Note that the doc is read-write here, but for the love of god, just leave it alone.
+    #
+    # @param [MARC4J4R::Record] r A marc record
+    # @param [SolrInputDocument, Hash] doc The document we're constructing. 
+    # @return [Array<String>] An array of values returned by the custom method
     
     def raw_marc_values r, doc
-      return @module.send(@methodSymbol, doc, r, *@methodArgs)
+      return @module.send(@functionSymbol, doc, r, *@methodArgs)
     end
     
+    
     def self.fromHash h
       return self.new(h)
     end
@@ -94,8 +119,8 @@ module MARCSpec
       
       s.print(":module => ")
       PP.singleline_pp(@module, s)
-      s.print(",\n :methodSymbol => ")
-      PP.singleline_pp(@methodSymbol, s)
+      s.print(",\n :functionSymbol => ")
+      PP.singleline_pp(@functionSymbol, s)
       if @methodArgs
         s.print(",\n :methodArgs => ")
         PP.singleline_pp(@methodArgs, s)

data/lib/marcspec/kvmap.rb

@@ -8,6 +8,8 @@ module MARCSpec
 
   # A KVMap is, when push comes to shove, just a hash with a name, and the 
   # option of adding a default value for each lookup.
+  #
+  # The map portion of a kvmap is simply a hash.
   
   class KVMap < Map
     
@@ -38,12 +40,18 @@ module MARCSpec
       end
     end    
     
+    # Set an element in the map, just like for a regular hash
     def []= key, value
       @map[key] = value
     end
     
     alias_method :add, :[]=
     
+    
+    # Produce a configuration file that will round-trip to this object.
+    #
+    # @return [String] A string representation of valid ruby code that can be turned back into 
+    # this object using MARCSpec::Map#fromFile
     def asPPString
       s = StringIO.new
       s.print "{\n :maptype=>:kv,\n :mapname=>"
@@ -54,7 +62,11 @@ module MARCSpec
       return s.string
     end
     
-        
+    
+    # Translate from a solrmarc map file that has *already been determined* to be a KV map
+    # @param [String] filename The path to the solrmarc kv map file
+    # @return [MARCSpec::KVMap] a KVMap
+    
     def self.from_solrmarc_file filename
       mapname = File.basename(filename).sub(/\..+?$/, '')
       map = {}

data/lib/marcspec/leaderspec.rb

@@ -0,0 +1,37 @@
+require 'marcspec/controlfieldspec'
+
+module MARCSpec
+  # A LeaderSpec deals only with the leader. It's basically the same as a controlfield spec, but
+  # using the string 'LDR' to identify itself
+  
+  class LeaderSpec < ControlFieldSpec
+    
+    # Built to be syntax-compatible with ControlFieldSpec, the tag must always
+    # be 'LDR' (case matters)
+    #
+    # @param ['LDR'] tag The 'tag'; in this case, always 'LDR'
+    # @param [Fixnum, Range<Fixnum>] range substring specification (either one character or a range) to return
+    # instead of the whole leader.
+    
+    def initialize (tag, range=nil)
+      unless tag == 'LDR'
+        raise ArgumentError "Tag must be 'LDR' for a LeaderSpec"
+      end
+      @tag = 'LDR'
+      self.range = range
+    end
+    
+    # Return the appropriate value (either the leader or a subset of it) from the
+    # given record
+    #
+    # @param [MARC4J4R::Record] r A MARC4J4R Record
+    # @return [String] the leader or substring of the leader
+    def marc_values r
+      if @range
+        return r.leader[@range]
+      else
+        return r.leader
+      end
+    end
+  end    
+end

data/lib/marcspec/map.rb

@@ -2,7 +2,12 @@ module MARCSpec
   
   # A Map is just a named lookup table. The access
   # (via []) takes, in adition to a key, an optional
-  # default value to return 
+  # default value to return (e.g., val = map[key, defaultIfNotFound])
+  #
+  # We don't have the default be a part of the map because it might be used
+  # in several different contexts.
+  #
+  # NOTE: THIS IS AN ABSTRACT SUPERCLASS. DO NOT INSTANTIATE IT DIRECTLY
   
   class Map
     attr_accessor :mapname, :map
@@ -10,12 +15,21 @@ module MARCSpec
     # Create a new map. The passed map is either
     # a standard hash or a list of duples
     #
-    # @param
+    # @param [String] mapname The name of this map; can be used to find it later on.
+    # @param [Hash, Array<2-value-arrays>] map Either a normal key-value hash (for a KV Map) or an
+    # array of duples (2-value arrays) for a MultiValueMap.
     def initialize(mapname, map)
       @mapname = mapname
       @map = map
     end
 
+    # Load a map from a file, determining what kind it is along the way.
+    #
+    # The file is valid ruby code; see the subclasses KVMap and MutlValueMap for examples.
+    #
+    # @param [String] filename The name of the map file to be eval'd 
+    # @return MARC2Solr::Map An instance of a subclass of MARC2Solr::Map
+    
     def self.fromFile filename
       begin
         str = File.open(filename).read
@@ -44,14 +58,18 @@ module MARCSpec
     end
       
 
+    # Check for map equality
     def == other
       return ((other.mapname == self.mapname) and (other.map = self.map))
     end
     
+    # Generic pretty_print; used mostly for translating from solrmarc
     def pretty_print pp
       pp.pp eval(self.asPPString)
     end
     
+    # Produce a map from the data structure produced by asPPString
+    # @param [Hash] rawmap A hash with two keys; :mapname and :map
     def self.fromHash rawmap
       return self.new(rawmap[:mapname], rawmap[:map])
     end

data/lib/marcspec/marcfieldspec.rb

@@ -1,207 +1,3 @@
-require 'marc4j4r'
-require 'set'
-require 'pp'
-module MARCSpec
-
-  # A ControlFieldSpec takes a control tag (generally 001..009) and an optional zero-based range
-  # When called with marc_values(record), it returns either the complete value of all
-  # occurances of the field in question (in the order they appear in the record), or 
-  # the zero-based substrings based on the passed range. 
-  #
-  # @example Get the whole 001
-  # cfs = MARCSpec::ControlTagSpec.new('001')
-  # 
-  # @example Get the first three characters of the 008
-  # cfs = MARCSpec::ControlTagSpec.new('001', 0..2)
-  #
-  # Note that the use of the zero-based range in this manner conforms to the way MARC 
-  # substrings are specified.
-  
-  class ControlFieldSpec
-    attr_accessor :tag, :range
-    
-    def initialize (tag, range=nil)
-      unless MARC4J4R::ControlField.control_tag? tag
-        raise ArgumentError "Tag must be a control tag"
-      end
-      @tag = tag
-      self.range = range
-    end
-    
-    def == other
-      return ((self.tag == other.tag) and
-              (self.range = other.range))
-    end
-    
-    
-    # Always force a real range, since in Ruby 1.9 a string subscript with a single fixnum
-    # will return the character code of that character (e.g., "Bill"[0] => 66, wherease 
-    # "Bill"[0..0] gives the expected 'B'
-    #
-    # @param [nil, Fixnum, Range] range A zero-based substring range or character position
-    # @return [MARCSpec::ControlFieldSpec] self
-    
-    def range= range
-      if range.nil?
-        @range = nil
-        return self
-      end
-      if range.is_a? Fixnum
-        if range < 0
-          raise ArgumentError, "Range must be nil, an integer offset (1-based), or a Range, not #{range}"
-        end
-      
-        @range = range..range
-      
-      elsif range.is_a? Range
-        @range = range
-      else
-        raise ArgumentError, "Range must be nil, an integer offset (1-based), or a Range, not #{range.inspect}"
-      end
-      return self
-    end
-    
-    
-    def marc_values r
-      vals = r.find_by_tag(@tag).map {|f| f.value}
-      if @range
-        return vals.map {|v| v[@range]}
-      else
-        return vals
-      end
-    end
-    
-    def pretty_print pp
-      pp.pp eval(self.asPPString)
-    end
-    
-    def asPPString
-      s = StringIO.new
-      if @range
-        PP.pp([@tag, @range], s)
-      else
-        PP.pp([@tag], s)
-      end
-      return s.string
-    end
-    
-    def self.fromPPString str
-      a = eval(str)
-      return self.new(*a)
-    end
-    
-  end
-  
-  
-  # A LeaderSpec deals only with the leader. It's basically the same as a controlfield spec, but
-  # using the string 'LDR' to identify itself
-  
-  class LeaderSpec < ControlFieldSpec
-    
-    # Built to be syntax-compatible with ControlFieldSpec, the tag must always
-    # be 'LDR' (case matters)
-    #
-    # @param ['LDR'] tag The 'tag'; in this case, always 'LDR'
-    # @param [Fixnum, Range<Fixnum>] range substring specification (either one character or a range) to return
-    # instead of the whole leader.
-    
-    def initialize (tag, range=nil)
-      unless tag == 'LDR'
-        raise ArgumentError "Tag must be 'LDR'"
-      end
-      @tag = 'LDR'
-      self.range = range
-    end
-    
-    # Return the appropriate value (either the leader or a subset of it) from the
-    # given record
-    #
-    # @param [MARC4J4R::Record] r A MARC4J4R Record
-    # @return [String] the leader or substring of the leader
-    def marc_values r
-      if @range
-        return r.leader[@range]
-      else
-        return r.leader
-      end
-    end
-  end    
-    
-  
-  # A VariableFieldSpec has a tag (three chars) and a set of codes. Its #marc_values(r) method will return
-  # all the values for the subfields for the given codes joined by the optional joiner (space by default)
-  #
-  # The subfield values are presented in the order they appear in the document, *not* the order the subfield
-  # codes are specified
-  #
-  # @example Get the $a from the 245s
-  # vfs = MARCSpec::VariableFieldSpec.new('245', 'a')
-  #
-  # vfs = MARCSpec::VariableFieldSpec.new('245', 'ab')
-  
-  
-  class VariableFieldSpec
-    
-    attr_accessor :tag, :codes, :joiner
-    
-    def initialize tag, codes=nil, joiner=' '
-      @tag = tag
-      @joiner = joiner || ' '
-      self.codes = codes
-    end
-    
-    def == other
-      return ((self.tag == other.tag) and
-              (self.codes = other.codes) and
-              (self.joiner = other.joiner))
-    end
-    
-    def codes= c
-      if c.nil?
-        @codes = nil
-        return nil
-      end
-      
-      if( c.is_a? Array) or (c.is_a? Set) or (c.is_a? Range)
-        @codes = c.to_a
-      else
-        @codes = c.split(//)
-      end
-
-      return @codes
-    end
-    
-    def marc_values r
-      fields = r.find_by_tag(@tag)
-      vals = []
-      fields.each do |f|
-        subvals = f.sub_values(@codes)
-        subvals =  subvals.join(@joiner) if subvals.size > 0 and (@codes.nil? or @codes.size > 1)
-        vals << subvals
-      end
-      vals.flatten!
-      return vals
-    end
-
-    def pretty_print pp
-      pp.pp eval(self.asPPString)
-    end
-    
-    def asPPString
-      s = StringIO.new
-      if @joiner and @joiner != ' '
-        PP.pp([@tag, '*', '*', @codes.join(''), @joiner], s)
-      else
-        PP.pp([@tag, '*', '*', @codes.join('')], s)
-      end
-      return s.string
-    end
-
-   def self.fromPPString str
-     a = eval(str)
-     return self.new(a[0], a[3], a[4])
-   end
-
-  end
-  
-end   
+require 'marcspec/controlfieldspec';
+require 'marcspec/variablefieldspec';
+require 'marcspec/leaderspec';

data/lib/marcspec/variablefieldspec.rb

@@ -0,0 +1,80 @@
+require 'set'
+require 'pp'
+module MARCSpec
+  # A VariableFieldSpec has a tag (three chars) and a set of codes. Its #marc_values(r) method will return
+  # all the values for the subfields for the given codes joined by the optional joiner (space by default)
+  #
+  # The subfield values are presented in the order they appear in the document, *not* the order the subfield
+  # codes are specified
+  #
+  # @example Get the $a from the 245s
+  # vfs = MARCSpec::VariableFieldSpec.new('245', 'a')
+  # vfs = MARCSpec::VariableFieldSpec.new('245', 'ab')
+  # vfs =  MARCSpec::VariableFieldSpec.new('245', ['a', 'b'])
+  # vfs =  MARCSpec::VariableFieldSpec.new('245', 'a'..'b')
+  
+  class VariableFieldSpec
+
+    attr_accessor :tag, :codes, :joiner
+
+    def initialize tag, codes=nil, joiner=' '
+      @tag = tag
+      @joiner = joiner || ' '
+      self.codes = codes
+    end
+
+    def == other
+      return ((self.tag == other.tag) and
+              (self.codes = other.codes) and
+              (self.joiner = other.joiner))
+    end
+
+    def codes= c
+      if c.nil?
+        @codes = nil
+        return nil
+      end
+
+      if( c.is_a? Array) or (c.is_a? Set) or (c.is_a? Range)
+        @codes = c.to_a
+      else
+        @codes = c.split(//)
+      end
+
+      return @codes
+    end
+
+    def marc_values r
+      fields = r.find_by_tag(@tag)
+      vals = []
+      fields.each do |f|
+        subvals = f.sub_values(@codes)
+        subvals =  subvals.join(@joiner) if subvals.size > 0 and (@codes.nil? or @codes.size > 1)
+        vals << subvals
+      end
+      vals.flatten!
+      return vals
+    end
+
+    def pretty_print pp
+      pp.pp eval(self.asPPString)
+    end
+
+    def asPPString
+      s = StringIO.new
+      if @joiner and @joiner != ' '
+        PP.pp([@tag, '*', '*', @codes.join(''), @joiner], s)
+      else
+        PP.pp([@tag, '*', '*', @codes.join('')], s)
+      end
+      return s.string
+    end
+
+   def self.fromPPString str
+     a = eval(str)
+     return self.new(a[0], a[3], a[4])
+   end
+
+  end
+
+end

data/spec/controlfieldspec_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+# LEADER 00734njm a2200217uu 4500
+# 001    afc99990058366
+# 003    DLC
+# 005    20071104155141.9
+# 007    sd ummunniauub
+# 008    071103s1939    xxufmnne||||||||| u eng||
+# 010    $a afc99990058366
+# 040    $a DLC $c DLC
+# 245 04 $a The Texas ranger $h [sound recording] / $c Sung by Beale D. Taylor.
+# 260    $a Medina, Texas, $c 1939.
+# 300    $a 1 sound disc : $b analog, 33 1/3 rpm, mono. ; $c 12 in.
+# 651  0 $a Medina $z Texas $z United States of America.
+# 700 1  $a Lomax, John Avery, 1867-1948 $e Recording engineer.
+# 700 1  $a Lomax, Ruby T. (Ruby Terrill) $e Recording engineer.
+# 700 1  $a Taylor, Beale D. $e Singer.
+# 852    $a American Folklife Center, Library of Congress
+# 852    $a DLC
+
+describe "ControlFieldSpec" do
+
+  before do
+    @one = MARC4J4R::Reader.new("#{DIR}/data/one.dat").first
+    # @batch = MARC4J4R::Reader.new("#{DIR}/batch.dat").collect
+  end
+
+  # afc99990058366 # data
+  # 01234567890123 # index
+  it "gets a single full value" do
+    cfs = MARCSpec::ControlFieldSpec.new('001')
+    cfs.marc_values(@one).should.equal ["afc99990058366"]    
+  end
+  
+  it "gets a single character" do
+    cfs = MARCSpec::ControlFieldSpec.new('001', 10 )
+    cfs.marc_values(@one).should.equal ['8']
+  end
+  
+  it "gets a range of characters" do
+    cfs = MARCSpec::ControlFieldSpec.new('001', 6..10 )
+    cfs.marc_values(@one).should.equal ['90058']
+  end
+  
+  it "should round trip" do
+    cfs = MARCSpec::ControlFieldSpec.new('001', 6..10 )
+    cfs2 = MARCSpec::ControlFieldSpec.fromPPString(cfs.asPPString)
+    cfs.should.equal cfs2
+  end    
+end
+
+

data/spec/leaderspec_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+# LEADER 00734njm a2200217uu 4500
+# 001    afc99990058366
+# 003    DLC
+# 005    20071104155141.9
+# 007    sd ummunniauub
+# 008    071103s1939    xxufmnne||||||||| u eng||
+# 010    $a afc99990058366
+# 040    $a DLC $c DLC
+# 245 04 $a The Texas ranger $h [sound recording] / $c Sung by Beale D. Taylor.
+# 260    $a Medina, Texas, $c 1939.
+# 300    $a 1 sound disc : $b analog, 33 1/3 rpm, mono. ; $c 12 in.
+# 651  0 $a Medina $z Texas $z United States of America.
+# 700 1  $a Lomax, John Avery, 1867-1948 $e Recording engineer.
+# 700 1  $a Lomax, Ruby T. (Ruby Terrill) $e Recording engineer.
+# 700 1  $a Taylor, Beale D. $e Singer.
+# 852    $a American Folklife Center, Library of Congress
+# 852    $a DLC
+
+describe "LeaderSpec" do
+  before do
+    @one = MARC4J4R::Reader.new("#{DIR}/data/one.dat").first
+  end
+  
+  it "Works with full leader" do
+    cfs = MARCSpec::LeaderSpec.new('LDR')
+    cfs.marc_values(@one).should.equal @one.leader
+  end
+  
+  it "Works with substring of leader" do
+    cfs = MARCSpec::LeaderSpec.new('LDR', 3..5)
+    cfs.marc_values(@one).should.equal @one.leader[3..5]
+  end
+end

data/spec/solrfieldspec_spec.rb

@@ -165,29 +165,29 @@ describe "CustomSolrSpec" do
   end
   
   it "works with no args or map" do
-    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :methodSymbol=>:titleUp)
+    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :functionSymbol=>:titleUp)
     css.marc_values(@one).should.equal [@one['245'].value.upcase]
   end
 
   it "accepts nil for no args" do
-    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :methodSymbol=>:titleUp, :methodArgs=>nil)
+    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :functionSymbol=>:titleUp, :methodArgs=>nil)
     css.marc_values(@one).should.equal [@one['245'].value.upcase]
   end
 
   
   it "uses a custom method with args but no map" do
-    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :methodSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
+    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :module=>A::B, :functionSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
     css.marc_values(@one).should.equal [@titleACValue.upcase]
   end
   
   it "works with a map" do
-    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :map=>@map, :module=>A::B, :methodSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
+    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :map=>@map, :module=>A::B, :functionSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
     css.marc_values(@one).should.equal [@mapValue]
   end
   
   it "works with a map that has multiple return values" do 
     @map[@titleACValue.upcase] = ['two', 'one']
-    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :map=>@map, :module=>A::B, :methodSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
+    css = MARCSpec::CustomSolrSpec.new(:solrField=>'solrField', :map=>@map, :module=>A::B, :functionSymbol=>:titleUp, :methodArgs=>[['a', 'c']])
     css.marc_values(@one).should.equal ['two', 'one']
   end
   

data/spec/specset_spec.rb

@@ -65,7 +65,7 @@ describe "SpecSet Basics" do
   end
   
   it "allows customs that reference previous work" do
-    @speclist << {:solrField=>'titleSort', :module=>A::B, :methodSymbol=>:sortable, :methodArgs=>['title']}
+    @speclist << {:solrField=>'titleSort', :module=>A::B, :functionSymbol=>:sortable, :methodArgs=>['title']}
     ss = MARCSpec::SpecSet.new
     ss.buildSpecsFromList(@speclist)
     h = ss.hash_from_marc @one
@@ -86,7 +86,7 @@ describe "SpecSet Basics" do
   it "should allow multi-headed custom fields" do
     @speclist << {:solrField => ['one', 'two', 'letters'],
                   :module => A::B,
-                  :methodSymbol => :three_value_custom,
+                  :functionSymbol => :three_value_custom,
       }
     ss = MARCSpec::SpecSet.new
     ss.buildSpecsFromList(@speclist)

data/spec/{marcfieldspecs_spec.rb → variablefieldspec_spec.rb}

@@ -18,56 +18,6 @@ require 'spec_helper'
 # 852    $a American Folklife Center, Library of Congress
 # 852    $a DLC
 
-describe "ControlFieldSpec" do
-
-  before do
-    @one = MARC4J4R::Reader.new("#{DIR}/data/one.dat").first
-    # @batch = MARC4J4R::Reader.new("#{DIR}/batch.dat").collect
-  end
-
-  # afc99990058366 # data
-  # 01234567890123 # index
-  it "gets a single full value" do
-    cfs = MARCSpec::ControlFieldSpec.new('001')
-    cfs.marc_values(@one).should.equal ["afc99990058366"]    
-  end
-  
-  it "gets a single character" do
-    cfs = MARCSpec::ControlFieldSpec.new('001', 10 )
-    cfs.marc_values(@one).should.equal ['8']
-  end
-  
-  it "gets a range of characters" do
-    cfs = MARCSpec::ControlFieldSpec.new('001', 6..10 )
-    cfs.marc_values(@one).should.equal ['90058']
-  end
-  
-  it "should round trip" do
-    cfs = MARCSpec::ControlFieldSpec.new('001', 6..10 )
-    cfs2 = MARCSpec::ControlFieldSpec.fromPPString(cfs.asPPString)
-    cfs.should.equal cfs2
-  end    
-end
-
-
-describe "LeaderSpec" do
-  before do
-    @one = MARC4J4R::Reader.new("#{DIR}/data/one.dat").first
-  end
-  
-  it "Works with full leader" do
-    cfs = MARCSpec::LeaderSpec.new('LDR')
-    cfs.marc_values(@one).should.equal @one.leader
-  end
-  
-  it "Works with substring of leader" do
-    cfs = MARCSpec::LeaderSpec.new('LDR', 3..5)
-    cfs.marc_values(@one).should.equal @one.leader[3..5]
-  end
-end
-    
-  
-
 describe "VariableFieldSpec" do
   before do
     @one = MARC4J4R::Reader.new("#{DIR}/data/one.dat").first

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: marcspec
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - BillDueber
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-17 00:00:00 -04:00
+date: 2010-08-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,14 +96,16 @@ files:
 - Rakefile
 - VERSION
 - lib/marcspec.rb
+- lib/marcspec/controlfieldspec.rb
 - lib/marcspec/customspec.rb
 - lib/marcspec/kvmap.rb
+- lib/marcspec/leaderspec.rb
 - lib/marcspec/map.rb
 - lib/marcspec/marcfieldspec.rb
 - lib/marcspec/multivaluemap.rb
 - lib/marcspec/solrfieldspec.rb
 - lib/marcspec/specset.rb
-- lib/orig.rb
+- lib/marcspec/variablefieldspec.rb
 - spec/data/batch.dat
 - spec/data/one.dat
 - spec/data/umich/translation_maps/area_map.properties
@@ -121,11 +123,12 @@ files:
 - spec/data/umich/translation_maps/location_map.properties
 - spec/data/umich/umich_index.properties
 - spec/maps_spec.rb
-- spec/marcfieldspecs_spec.rb
-- spec/marcspec_spec.rb
 - spec/solrfieldspec_spec.rb
 - spec/spec_helper.rb
 - spec/specset_spec.rb
+- spec/controlfieldspec_spec.rb
+- spec/leaderspec_spec.rb
+- spec/variablefieldspec_spec.rb
 has_rdoc: true
 homepage: http://github.com/billdueber/marcspec
 licenses: []
@@ -161,9 +164,10 @@ signing_key:
 specification_version: 3
 summary: Extract data from MARC records and send to Solr
 test_files: 
+- spec/controlfieldspec_spec.rb
+- spec/leaderspec_spec.rb
 - spec/maps_spec.rb
-- spec/marcfieldspecs_spec.rb
-- spec/marcspec_spec.rb
 - spec/solrfieldspec_spec.rb
 - spec/spec_helper.rb
 - spec/specset_spec.rb
+- spec/variablefieldspec_spec.rb

data/lib/orig.rb

@@ -1,288 +0,0 @@
-require 'set'
-require 'pp'
-require 'logger'
-
-$LOG ||= Logger.new(STDERR)
-
-module MARCSpec
-
-  class MapSpec
-    attr_accessor :map, :type, :default
-    
-    def initialize(type, map, default=nil)
-      @type = type
-      @default = default
-      @map = map
-    end
-    
-    def [] key
-      if (@type == :kv)
-        if @map.has_key? key
-          return @map[key]
-        else
-          return @default
-        end
-      end
-      
-      # For a pattern, we find all that match. 
-      
-      if (@type == :pattern)
-        rv = []
-        @map.each do |pv|
-          pat = pv[0]
-          val = pv[1]
-#          puts "Trying pattern #{pat} against #{key}"
-          if pat.match(key)
-            rv << val
-#            puts "Matched: adding #{val}"
-          end
-        end
-        rv.uniq!
-        if rv.size > 0
-          return  rv
-        else 
-          return @default
-        end
-      end
-    end
-  end
-  
-  class CustomSpec
-    def initialize(proc, args)
-      @proc = proc
-      @args = args
-    end
-    
-    def marc_values_hash fieldnames, r
-      a = @proc(r, args)
-      rv = {}
-      fieldnames.each_with_index do |fn, i|
-        rv[fn] = a[i]
-      end
-      return rv
-    end
-  end
-      
-    
-  class TagSpec
-    attr_accessor :tag, :codes, :joiner, :parent, :ind1, :ind2, :range, :is_control
-    
-    def initialize(tag, codes=nil)
-      @codes = Set.new
-      @tag = tag
-      @joiner = ' '
-      @substr = nil
-      tagint = tag.to_i
-      @is_control = (tagint != 0 and tagint < 10)
-      if (codes)
-        self.codes = codes
-      end
-    end
-    
-    def range= newrange
-      if newrange =~ /\s*(\d+)-(\d+)/
-        start = $1.to_i 
-        last =  $2.to_i
-        @range = start..last
-      else
-        se = newrange.to_i
-        @range = se..se
-      end
-    end
-    
-    def codes= newcodes
-      if newcodes.is_a? Range
-        @codes = newcodes.to_a
-      elsif newcodes !~ /\S/
-        @codes = nil
-      # Otherwise, just split into individual characters
-      else
-        @codes = newcodes.split(//)
-      end
-    end
-    
-    def marc_values r
-      if @is_control
-        vals = r.find_by_tag(@tag).map {|f| f.value}
-#        puts "Start with #{vals.join(', ')}"
-        if @range
-          vals.map! {|v| v[@range]}
-        end
-#        puts "End with #{vals.join(', ')}"
-        
-      else 
-        fields = r.find_by_tag(@tag)
-        vals = []
-        fields.each do |f|
-          subvals = f.sub_values(@codes)
-          vals << subvals.join(@joiner) if subvals.size > 0
-        end
-      end
-      # puts vals.join(', ')
-      return vals
-    end
-    
-  end
-  
-  class FieldSpec
-    attr_accessor :field, :first, :map, :tagspecs
-    
-    def initialize(opts)
-      @field  = opts[:field]
-      @first = opts[:first] || false
-      @map = opts[:map] || nil
-      @tagspecs = []
-    end
-    
-    def << tagspec
-      tagspec.parent = self
-      @tagspecs << tagspec
-    end
-    
-    def marc_values r
-      vals = []
-      # puts "Tagspecs has #{@tagspecs.size} items"
-      @tagspecs.each do |ts|
-        vals.concat ts.marc_values(r)
-        # puts vals.join(', ')
-        break if @first and vals.size > 0
-      end
-      
-      if (@map)
-        vals.map! {|v| @map[v]}
-        # vals.each do |v|
-        #   puts "Map: #{v} => #{@map[v].to_s}"
-        # end
-      end
-      vals.flatten!
-      vals.uniq!
-      vals.compact!
-      return vals
-    end
-    
-  end
-  
-  
-  class SpecSet
-    attr_accessor :tmaps, :fieldspecs
-    def initialize(*args)
-      tmapdir = args.pop!
-      unless File.directory? tmapdir
-        $LOG.error "Directory #{tmapdir} not found"
-        raise LoadError, "Directory #{tmapdir} not found"
-      end
-              
-      @tmaps = {}
-      Dir.glob(tmapdir + '/*.rb') do |fn|
-        basename = File.basename(fn).sub(/\.rb$/, '')
-        $LOG.info "Loading translation map #{basename}"
-        
-        begin
-          rawmap = eval(File.open(fn).read)
-          @tmaps[basename] = MapSpec.new(rawmap[:type], rawmap[:map], rawmap[:default])
-        rescue SyntaxError
-          $LOG.error "Error processing translation map file #{fn}: #{$!}"
-          raise SyntaxError, $!
-        end
-        
-      end
-      
-      @fieldspecs = []
-      
-    # Get the index files
-      args.each do |indexfile|
-        begin
-          unless File.exists? indexfile
-            $LOG.error "File #{indexfile} does not exist"
-            raise LoadError, "File #{indexfile} does not exist"
-          end
-          $LOG.info "Loading index file #{indexfile}"
-          rawindex = eval(File.open(indexfile).read)
-          rawindex.each do |entry|
-            fs = FieldSpec.new(:field => entry[:solrField], :first=>entry[:firstOnly])
-            mapname = entry[:map]
-            if mapname
-              if @tmaps.has_key? mapname
-                fs.map = @tmaps[mapname]
-              else 
-                $LOG.error "Can't find map #{mapname}"
-              end
-            end
-            entry[:specs].each do |entryts|
-            
-              # A one- or two-element entry is a control field
-              # A three element entry (tag, ind1, ind2) is all subs of a field (need to implement)
-              # A four element field is tag, ind1, ind2, subs
-              # A five element field is tag, ind1, ind2, subs, joiner
-              
-            
-              tag = entryts[0]
-            
-              # Is tag the symbol :custom? Then make it a custom item
-            
-              if tag == :custom
-                ts = CustomSpec.new(entryts[1], entryts[2..-1])
-                fs << ts
-                next
-              end
-            
-              # If it's not custom, the solrField better be a scale
-              if entry[:solrField].is_a? Array
-                # log an error and bail out
-              end
-            
-              # Otherwise, it's a tag spec
-              if tag.is_a? Fixnum
-                tag = '%03d' % tag
-              end
-            
-            
-              ts = TagSpec.new(tag)
-              if entryts.size < 3
-                ts.is_control = true
-                ts.range = entryts[1] if entryts[1]
-              else
-                ts.ind1 = entryts[1]
-                ts.ind2 = entryts[2]            
-                ts.codes = entryts[3]
-                ts.joiner = entryts[4] if entryts[4]
-              end
-              fs << ts
-            end
-            self << fs
-          end
-        rescue SyntaxError
-          $LOG.error "Error processing index file #{indexfile}: #{$!}"
-          raise SyntaxError
-        end      
-      end
-    end
-    
-    def each
-      @fieldspecs.each do |fs|
-        yield fs
-      end
-    end
-    
-    def << fieldspec
-      @fieldspecs << fieldspec
-    end
-    
-    def doc_from_marc r
-      doc = SolrInputDocument.new
-      @fieldspecs.each do |fs|
-        doc[fs.field] = fs.marc_values(r)
-      end
-      return doc
-    end      
-    
-    def hash_from_marc r
-      h = {}
-      @fieldspecs.each do |fs|
-       h[fs.field] = fs.marc_values(r)
-      end
-      return h
-    end
-    
-  end
-end  

data/spec/marcspec_spec.rb

@@ -1,10 +0,0 @@
-
-
-
-
-
-
-
-
-
-