lc_callnumber 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 080e05e9e7c6084e500e3fb0ca2d827c4dc52474
-  data.tar.gz: 222d0cce1e42df11b29496b191da1ed60ae37e42
+  metadata.gz: d173a4ec0a1b4ba26c0beec642a3f66b845c67d4
+  data.tar.gz: 41a42a08153cb57f4f0c775794cbf72c56890369
 SHA512:
-  metadata.gz: 3291b552acdb8d6339d0043ac0cbe66e0e906f4b007c3e04a4dcc972a4947e299930bb1c66bbb999a6bb8510d0b55ec6b2611e59dc9aafe7f76077c70bcd76c5
-  data.tar.gz: 8d5840f2a39cbcee9aedb56135b7b556c2eb046615224331c4c40ff97bdbb59f08602154f2e5d9ff22831c03620d2ef95511d0cd6d182ec04eb81fd7229e425c
+  metadata.gz: 3aa66113e6ac592735e4bfdba100b7b174635054dc26b0d136d749329b48df6957233bef6d426e50d07ab794a0e010b23cdcbd6f04f1ce52703d28ad9b53fe1e
+  data.tar.gz: 686dc9b45975782c5c426af6430e0bec8d08c21fa41a6aff5dd4b7b768a2871fd51d8bfb48f1a43bb8fe0b1c36e286db1319131c35f272f586d8b96c2899cf43

data/README.md

@@ -32,7 +32,7 @@ For purposes of this class, an LC Call Number consists of the following parts. O
 
 * __Letter(s).__ One or more letters
 * __Digit(s).__ One or more digits, optionally with a decimal point. 
-* __Doon1 (_Date Or Other Number_)__. Relatively rare as these things go, a DOON is used to represent the date the work is _about_ (as opposed to, say, the year it was published) or, in some cases, an identifier for an army division or group (say, "12th" for the US Army Twelfth Infantry). 
+* __Doon1 (_Date Or Other Number_)__. [Note: no one but me calls it a 'doon', but I needed a term and there wasn't another]. Relatively rare as these things go, a DOON is used to represent the date the work is _about_ (as opposed to, say, the year it was published) or, in some cases, an identifier for an army division or group (say, "12th" for the US Army Twelfth Infantry). 
 * __First cutter__. The first "Cutter Number" consisting of a letter followed by one or more digits. The first cutter is always supposed to be preceded by a dot, but, you know, isn't always.
 * __Doon2__. Another date or other number
 * __"Extra" Cutters__. The 2nd through Nth Cutter numbers, lumped together because we don't have to worry about them getting interspersed with doons.

data/lib/lc_callnumber/lcc.rb

@@ -4,7 +4,7 @@ module LCCallNumber
 
   @parser = Parser.new
   @transformer = Transform.new
-  
+
   def self.parse(i)
     return UnparseableCallNumber.new(i) if i.nil?
     i.chomp!
@@ -13,13 +13,13 @@ module LCCallNumber
     i.gsub!(/\[(.+)\]/, "$1")
     i.gsub!('\\', ' ')
 
-    # We also have a bunch that start with a slash and have slashes where you'd 
+    # We also have a bunch that start with a slash and have slashes where you'd
     # expect logical breaks. Don't know why.
-    
+
     if i =~ /\A\//
       i.gsub!('/', ' ')
     end
-    
+
     # Ditch leading + or *
     i.gsub!(/\A[+*]/, '')
 
@@ -35,7 +35,7 @@ module LCCallNumber
        !(/\d/.match i)
        return UnparseableCallNumber.new(orig)
     end
-    
+
     begin
       p = @parser.parse(i)
       # puts p
@@ -46,12 +46,12 @@ module LCCallNumber
       return UnparseableCallNumber.new(orig)
     end
   end
-      
-      
-    
-    
-    
-    
+
+
+
+
+
+
 
   # The "lead" -- initial letter(s) and digit(s)
   class Lead
@@ -64,28 +64,28 @@ module LCCallNumber
       "Lead<#{letters}, #{digits.inspect}>"
     end
   end
-  
-  # A generic "Decimal" part, where we keep the 
+
+  # A generic "Decimal" part, where we keep the
   # integer and fractional parts separate so
   # we can construct a string more easily
-  
+
   class Decimal
     attr_accessor :intpart, :fractpart
     def initialize(i, f=nil)
       @intpart = i
       @fractpart = f
     end
-    
+
     def to_num
       fractpart ? "#{intpart}.#{fractpart}".to_f : intpart.to_i
     end
-    
+
     def to_s
       fractpart ? "#{intpart}.#{fractpart}" : intpart
     end
-    
-    
-    def inspect      
+
+
+    def inspect
       if fractpart
         "#{intpart}:#{fractpart}"
       else
@@ -93,36 +93,36 @@ module LCCallNumber
       end
     end
   end
-  
+
   # A "Cutter" is a single letter followed by one or more digits
   # It is sometimes preceded by a decimal point. We note whether or not
   # we got a decimal point because it may be a hint as to whether or not
   # we're actually looking at a Cutter.
-  
+
   class Cutter
     attr_accessor :letter, :digits, :dot
     def initialize(l,d, dot=nil)
-      @letter = l
-      @digits = d
+      @letter = l.to_s
+      @digits = d.to_i
       @dot = !dot.nil?
     end
-    
+
     def inspect
       "Cut<#{letter},#{digits}>"
     end
-    
+
     def to_s
       "#{letter}#{digits}"
     end
   end
-  
-  
+
+
   # Some call numbers have a year, infantry division, etc. preceeding
   # and/or following the first cutter. We take all three as a unit so
   # we can deal with edge cases more easily.
   #
   # "doon" in this case is "Date Or Other Number"
-  
+
   class FirstCutterSet
     attr_accessor :doon1, :cutter, :doon2
     def initialize(d1, cutter, d2)
@@ -131,84 +131,161 @@ module LCCallNumber
       @cutter = cutter
     end
   end
-  
+
   # Bring it all together in the callnumber
-  # We feed it the parts we have, and then reassign fields based on 
+  # We feed it the parts we have, and then reassign fields based on
   # what we have.
   #
   # To wit:
   #  Q123 .C4 1990 --- published in 1990
   #  Q123 .C4 1990 .D5 2003 -- published in 2003 with a 2nd doon of 1990
-  
-  
+
+
   class CallNumber
-        
-    attr_accessor :letters, :digits, :doon1, :firstcutter, :doon2, 
+
+    include Comparable
+    attr_accessor :letters, :digits, :doon1, :firstcutter, :doon2,
                   :extra_cutters, :year, :rest
     attr_accessor :original_string
-    
-                      
+
+
     def initialize(lead, fcset=nil, ec=[], year=nil, rest=nil)
-      @letters = lead.letters
+      @letters = lead.letters.to_s.upcase
       @digits  = lead.digits.to_num
-      
+
       if fcset
         @doon1   = fcset.doon1
         @doon2   = fcset.doon2
         @firstcutter = fcset.cutter
       end
-      
+
       @extra_cutters = ec
       @year = year
       @rest = rest
-      
+
       @rest.strip! if @rest
-      
+
       self.reassign_fields
     end
-    
+
     def reassign_fields
       # If we've got a doon2,  but no year and no extra cutters,
       # put the doon2 in the year
-      
+
       if doon2 and (doon2=~ /\A\d+\Z/) and extra_cutters.empty? and year.nil?
         @year = @doon2
         @doon2 = nil
       end
     end
-    
+
     def inspect
       header = %w(letters digits doon1 cut1 doon2 othercut)
       actual = [letters,digits,doon1,firstcutter,doon2,extra_cutters.join(','),year,rest].map{|x| x.to_s}
       fmt = '%-7s %-9s %-6s %-6s %-6s %-20s year=%-6s rest=%-s'
       [('%-7s %-9s %-6s %-6s %-6s %-s' % header), (fmt % actual)].join("\n")
-      
+
     end
-    
-    
-    def valid? 
+
+
+    def valid?
       @letters && @digits
     end
-    
+
+    def <=>(other)
+      # Make call numbers sortable.
+      # Work through the various parts, from left to right.
+      # (They compare as strings or numbers as appropriate, thanks to the above.)
+
+      letters_cmp = letters <=> other.letters
+      return letters_cmp unless letters_cmp == 0
+
+      digits_cmp = digits <=> other.digits
+      return digits_cmp unless digits_cmp == 0
+
+      doon1_cmp = doon1 <=> other.doon1
+      return doon1_cmp unless doon1_cmp == 0
+
+      # Cutters have letters and numbers, which we need to compare separately.
+      if firstcutter
+        if other.firstcutter
+          # Both have firstcutters!  Hurrah!
+          # Compare the letter
+          firstcutter_cmp = firstcutter.letter <=> other.firstcutter.letter
+          # If that didn't help, compare the digits
+          if firstcutter_cmp == 0
+            firstcutter_cmp = firstcutter.digits <=> other.firstcutter.digits
+          end
+          # If that didn't help, if other has an extra_cutter, it is last
+          if firstcutter_cmp == 0
+            firstcutter_cmp = -1 if (extra_cutters.empty? && ! other.extra_cutters.empty?)
+          end
+        else
+          # self has a firstcutter but other doesn't, so other is first
+          firstcutter_cmp = 1
+        end
+      else
+        # self has no firstcutter
+        if other.firstcutter
+          # other does, so it comes last
+          firstcutter_cmp = -1
+        else
+          # Neither has one, so carry on
+          firstcutter_cmp = 0
+        end
+      end
+      return firstcutter_cmp unless firstcutter_cmp == 0
+
+      doon2_cmp = doon2 <=> other.doon2
+      return doon2_cmp unless doon2_cmp == 0
+
+      # The extra_cutters are an array, so we need to compare each.
+      # Surely there is an easier way to do this?
+      extra_cutters_cmp = 0
+      # STDERR.puts extra_cutters
+      extra_cutters.each_index do |i|
+        if extra_cutters_cmp == 0 # Stop when we need go no further
+          # First, compare the letter
+          if other.extra_cutters[i]
+            extra_cutters_cmp = extra_cutters[i].letter <=> other.extra_cutters[i].letter
+            # If that didn't help, compare the digits
+            if extra_cutters_cmp == 0
+              extra_cutters_cmp = extra_cutters[i].digits <=> other.extra_cutters[i].digits
+            end
+            # If that didn't help, if self has no more extra_cutters but other does, self is first
+            if extra_cutters_cmp == 0
+              extra_cutters_cmp = -1 if (extra_cutters[i+1].nil? && other.extra_cutters[i+1])
+            end
+          else
+            # other has no extra_cutter, so it is first
+            extra_cutters_cmp = 1
+          end
+        end
+      end
+      return extra_cutters_cmp unless extra_cutters_cmp == 0
+
+      year_cmp = year <=> other.year
+      return year_cmp unless year_cmp == 0
+
+      rest_cmp = rest <=> other.rest
+      return rest_cmp
+
+    end
+
   end
-  
+
   class UnparseableCallNumber < CallNumber
 
     def initialize(str)
       self.original_string = str
       self.extra_cutters = []
     end
-      
-    def valid? 
+
+    def valid?
       false
     end
-    
+
   end
-    
-  
-  
+
+
+
 end
-  
-  
-  
-  

data/lib/lc_callnumber/version.rb

@@ -1,3 +1,3 @@
 module LCCallNumber
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/test_lc_callnumber.rb

@@ -22,11 +22,31 @@ describe "Basics" do
       assert_equal other_cutters.to_s.split(/\s*,\s*/), lc.extra_cutters.map(&:to_s), "#{orig} -> extra_cutters #{lc.inspect}"
       assert_equal pubyear.to_s, lc.year.to_s,  "#{orig} -> year #{lc.inspect}"
       assert_equal rest.to_s, lc.rest.to_s,  "#{orig} -> rest #{lc.inspect}"
-      
+
     end
-    
+
+  end
+end
+
+describe "Sorting" do
+  it "sorts call numbers properly" do
+    a1 = LCCallNumber.parse("A 50")
+    a2 = LCCallNumber.parse("A 7")
+    q1 = LCCallNumber.parse("QA 500")
+    q2 = LCCallNumber.parse("QA 500.M500")
+    q3 = LCCallNumber.parse("QA 500.M500 T59")
+    q4 = LCCallNumber.parse("QA 500.M500 T60")
+    q5 = LCCallNumber.parse("QA 500.M500 T60 A1")
+    q6 = LCCallNumber.parse("QA 500.M500 T60 Z54")
+    assert (a1 <=> a1) ==  0 # a1 is a1
+    assert (a1 <=> a2) ==  1 # a1 > a2
+    assert (a2 <=> q1) == -1 # a2 < q1
+    assert (q1 <=> q2) == -1 # q1 < q2
+    assert (q2 <=> q3) == -1 # q2 < q3
+    assert (q3 <=> q3) ==  0 # q3 is q3
+    assert (q3 <=> q4) == -1 # q3 < q4
+    assert (q4 <=> q5) == -1 # q4 < q5
+    assert (q5 <=> q6) == -1 # q5 < q6
+    # Is there some way to put some test numbers into an array, sort it, and compare the original and sorted arrays?
   end
 end
-      
-      
-      

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lc_callnumber
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Bill Dueber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Work with  LC Call (Classification) Numbers, including an attempt to parse
@@ -116,3 +116,4 @@ test_files:
 - test/minitest_helper.rb
 - test/test_data/basics.txt
 - test/test_lc_callnumber.rb
+has_rdoc: