lc_callnumber 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 080e05e9e7c6084e500e3fb0ca2d827c4dc52474
+  data.tar.gz: 222d0cce1e42df11b29496b191da1ed60ae37e42
+SHA512:
+  metadata.gz: 3291b552acdb8d6339d0043ac0cbe66e0e906f4b007c3e04a4dcc972a4947e299930bb1c66bbb999a6bb8510d0b55ec6b2611e59dc9aafe7f76077c70bcd76c5
+  data.tar.gz: 8d5840f2a39cbcee9aedb56135b7b556c2eb046615224331c4c40ff97bdbb59f08602154f2e5d9ff22831c03620d2ef95511d0cd6d182ec04eb81fd7229e425c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+bundler_args: --without documentation
+rvm:
+  - 1.9.3
+  - 2.1
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lc_callnumber.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Bill Dueber
+
+MIT License
+
+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,91 @@
+[![Build Status](https://secure.travis-ci.org/billdueber/lc_callnumber.png)](http://travis-ci.org/billdueber/lc_callnumber)
+
+# LCCallNumber
+
+Very simple attempt to work with Library of Congress Call Numbers (_nee_ Classification Numbers).
+Includes simple getters/setters and a PEG parser.
+
+
+## Things that aren't yet done
+
+* Normalization: create a string that can be compared with other normalized strings to correctly order the call numbers
+* Implement `<=>` so call number object can be compared.
+* Much better testing
+
+
+## Parts of an LC Call Number
+
+LC Call Numbers are used in libraries to classify and order books and other items.
+
+Some (increasingly complex) samples are:
+
+* A1
+* A1.2 .B3
+* A1.2 .B3 .C4
+* A1.2 .B3 1990
+* A1.2 1888 .B3 .C4 2000
+* A1.2 .A54 21st 2010
+
+The OCLC has [a page explaining how LC Call Numbers are composed](http://www.oclc.org/bibformats/en/0xx/050.html), which you should reference if you feel the need.
+
+For purposes of this class, an LC Call Number consists of the following parts. Only the first two are required; everything else is optional.
+
+* __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). 
+* __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.
+* __Year__. The year of publication
+* __"Rest"__. Everything and anything else. 
+
+## Usage
+
+In general, you won't be building these things up by hand; you'll try to parse them.
+
+Note that in the case below, while in theory this could be a callnumber with a single cutter followed by a doon2 and no year, we presume the '1990' is a year and don't call it a doon.
+
+~~~ruby
+
+require 'lc_callnumber'
+
+lc = LCCallNumber.parse('A1.2 .B3 1990') #=> LCCallNumber::CallNumber
+lc.letters #=> 'A'
+lc.digits  #=> 1.2 (as a float for a float; int if there's no decimal)
+lc.doon1   #=> nil
+lc.firstcutter #=> Cutter<letter=>'B', digits=>'3', dot=>true>
+lc.extra_cutters #=> []
+lc.year      #=> 1990
+lc.rest      #=> nil
+
+lc = LCCallNumber.parse('A .B3') #=> LCCallNumber::UnparseableCallNumber
+lc.valid? #=> false
+
+~~~
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lc_callnumber'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lc_callnumber
+
+
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+end
+
+task :default => :test

data/lc_callnumber.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lc_callnumber/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lc_callnumber"
+  spec.version       = LCCallNumber::VERSION
+  spec.authors       = ["Bill Dueber"]
+  spec.email         = ["bill@dueber.com"]
+  spec.description   = %q{Work with  LC Call (Classification) Numbers}
+  spec.summary       = %q{Work with  LC Call (Classification) Numbers, including an attempt to parse them out from a string to their component parts}
+  spec.homepage      = "https://github.com/billdueber/lc_callnumber"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'parslet'
+  
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/lib/lc_callnumber/lcc.rb

@@ -0,0 +1,214 @@
+require 'lc_callnumber/parser'
+
+module LCCallNumber
+
+  @parser = Parser.new
+  @transformer = Transform.new
+  
+  def self.parse(i)
+    return UnparseableCallNumber.new(i) if i.nil?
+    i.chomp!
+    i.strip!
+    orig = i
+    i.gsub!(/\[(.+)\]/, "$1")
+    i.gsub!('\\', ' ')
+
+    # 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[+*]/, '')
+
+    # Strip off any leading/trailing spaces and upcase it
+    i.strip!
+    i.upcase!
+
+    # Don't bother if it starts with a number, four letters, or the string 'law'
+    # Don't bother if there's no numbers at all
+    if (/\A\d/.match i) or
+       (/\A[[:alpha:]]{4}/.match i) or
+       (/\ALAW/i.match i) or
+       !(/\d/.match i)
+       return UnparseableCallNumber.new(orig)
+    end
+    
+    begin
+      p = @parser.parse(i)
+      # puts p
+      lc = @transformer.apply(p)
+      lc.original_string = orig
+      return lc
+    rescue Parslet::ParseFailed => e
+      return UnparseableCallNumber.new(orig)
+    end
+  end
+      
+      
+    
+    
+    
+    
+
+  # The "lead" -- initial letter(s) and digit(s)
+  class Lead
+    attr_accessor :letters, :digits
+    def initialize(l, d)
+      @letters = l
+      @digits = d
+    end
+    def inspect
+      "Lead<#{letters}, #{digits.inspect}>"
+    end
+  end
+  
+  # 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      
+      if fractpart
+        "#{intpart}:#{fractpart}"
+      else
+        "#{intpart}"
+      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
+      @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)
+      @doon1 = d1
+      @doon2 = d2
+      @cutter = cutter
+    end
+  end
+  
+  # Bring it all together in the callnumber
+  # 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, 
+                  :extra_cutters, :year, :rest
+    attr_accessor :original_string
+    
+                      
+    def initialize(lead, fcset=nil, ec=[], year=nil, rest=nil)
+      @letters = lead.letters
+      @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? 
+      @letters && @digits
+    end
+    
+  end
+  
+  class UnparseableCallNumber < CallNumber
+
+    def initialize(str)
+      self.original_string = str
+      self.extra_cutters = []
+    end
+      
+    def valid? 
+      false
+    end
+    
+  end
+    
+  
+  
+end
+  
+  
+  
+  

data/lib/lc_callnumber/parser.rb

@@ -0,0 +1,113 @@
+require 'parslet'
+require 'lc_callnumber/lcc'
+
+module LCCallNumber
+  class Parser < Parslet::Parser
+    rule(:space)  { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:dot)    { str('.') }
+    rule(:dot?)   { dot.maybe }
+    
+    rule(:digit)  { match('\d') }
+    rule(:digits) { digit.repeat(1) }
+    rule(:digits?) { digits.maybe }
+    
+    rule(:year) { digits }
+    
+    rule(:firstletter) { match('(?i:[A-HJ-NP-VZ])') }
+    rule(:letter) { match('(?i:[A-Z])') }
+    rule(:a2) { firstletter >> letter.maybe }
+    rule(:a3) { 
+      match['K'] >> letter.repeat(2) |
+      str('DAW') |
+      str('DJK')
+    }
+    
+    rule(:alpha) {
+      a3 | 
+      a2
+    }
+    
+    # Numeric string may or may not have a dot
+    rule(:numstring) {
+      digits.as(:intpart) >> (dot >> digits.as(:fractpart)).maybe 
+    }
+    
+    # So, the "lead" is what I'm calling the necessary part of the callnumber,
+    # the letter(s) and following number
+    rule(:lead) {
+      (alpha.as(:alpha) >> space? >> numstring.as(:numbers)).as(:lead) 
+      #|
+      #(alpha.as(:alpha) >> space).as(:lead)
+    }
+    
+    
+    # "Date or other number" -- need to take into account 1st, 2nd, etc.
+    # Should probably restrict this so that, e.g., you can't have "2rd"
+    # but for now this is sufficient.
+    rule(:suffix) {
+      str('ST') |
+      str('ND') |
+      str('RD') | 
+      str('TH')
+    }
+    
+    rule(:doon) {
+      dot? >> digits.as(:digits) >> space? >> suffix.as(:suffix) |
+      digits.as(:digits)
+    }
+    rule(:doon?) { doon.maybe }
+      
+    # Cutter is a letter followed by numbers
+    rule(:dotcutter) { (dot.as(:dot) >> letter.as(:letter) >> digits.as(:digits)).as(:cutter) }
+    rule(:odotcutter) { ((dot.maybe).as(:dot) >> letter.as(:letter) >> digits.as(:digits)).as(:cutter) }
+    
+    # # Firstcutter has to have a dot
+    # rule(:dotcutter) { dot >> cutter }
+    # rule(:odotcutter) { (dot.maybe).as(:dot) >> cutter}
+    
+    # The first cutter set can have doons on either side
+    rule(:firstcutterset) {
+      ((doon >> space).maybe).as(:doon1) >> odotcutter.as(:cutter) >> ((space >>  doon).maybe).as(:doon2)
+    }
+   
+    # Other cutters may or may not have a dot
+    rule(:extracutters) {
+      (space? >> odotcutter).repeat(0)
+    }
+    
+    rule(:cutters) {
+      odotcutter >> extracutters
+    }
+   
+    # The rest of it, if there is anything but spaces
+    rule(:rest) {
+      space? >> any.repeat(1)
+    }
+
+    rule(:lcclass) {
+      lead >> space? >> (firstcutterset).as(:fcset) >> extracutters.as(:ec) >> ((space >>  year.as(:yeardigits)).maybe).as(:year) >> (rest.maybe).as(:rest) | 
+      lead >> ((space >>  year.as(:yeardigits)).maybe).as(:year) >> (rest.maybe).as(:rest)
+    }
+    root(:lcclass)
+  end
+  
+  
+  
+  class Transform < Parslet::Transform
+    rule(:intpart=>simple(:i), :fractpart=>simple(:f)) { Decimal.new(i,f) }
+    rule(:intpart=>simple(:i)) { Decimal.new(i,nil) }
+    
+    rule(:alpha=>simple(:a), :numbers=>simple(:n)) { @a = Lead.new(a.to_s,n) }
+    rule(:digits=>simple(:d), :suffix=>simple(:s)) {"#{d}#{s}"}
+    rule(:digits=>simple(:d)) { d.to_s }
+    rule(:doon => simple(:d)) { d.to_s.strip }
+    rule(:cutter => {:dot=>simple(:dot), :letter=>simple(:l), :digits=>simple(:d)}) { Cutter.new(l.to_s,d.to_s, !(dot.nil?))}
+    
+    rule(:doon1=>simple(:d1), :doon2=>simple(:d2), :cutter=>simple(:c)) { FirstCutterSet.new(d1, c, d2)}
+    rule(:yeardigits => simple(:y)) { y.nil? ? nil : y.to_s.strip}
+    rule(:lead=>simple(:l), :fcset=>simple(:fc), :ec=>sequence(:ec), :year=>simple(:year), :rest=>simple(:rest)) { CallNumber.new(l,fc,ec,year,rest.to_s)}
+    rule(:lead=>simple(:l), :year=>simple(:year), :rest=>simple(:rest)) {CallNumber.new(l,nil,[],year,rest.to_s)}
+  end
+  
+end

data/lib/lc_callnumber/version.rb

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

data/lib/lc_callnumber.rb

@@ -0,0 +1,4 @@
+require "lc_callnumber/version"
+require 'lc_callnumber/lcc'
+require 'lc_callnumber/parser'
+

data/test/minitest_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'lc_callnumber'
+
+
+def test_data(relative_path)
+  return File.expand_path(File.join("test_data", relative_path), File.dirname(__FILE__))
+end
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+
+

data/test/test_data/basics.txt

@@ -0,0 +1,26 @@
+#Tab-delimited file, exported from https://docs.google.com/spreadsheet/ccc?key=0AvHn-9AM-38ldE5TYjFvWFFTdnU5emltMEhuQzEyRnc#gid=0								
+# String	Letter(s)	Number	Doon1	Cutter1	Doon2	Other,Cutters	PubYear	Rest
+A1	A	1						
+A1 .C2	A 	1		C2				
+A1 C2	A	1		C2				
+A10.4	A	10.4						
+A10.4 C345	A 	10.4		C345				
+A1 1990	A	1					1990	
+A 1 C22	A	1		C22				
+BF 173 .F889 F92	BF	173		F889		F92		
+HD7123 .A5 1970 b	HD	7123		A5			1970	b
+PJ5054.B5N44 I83	PJ	5054		B5		N44,I83		
+DA 690 .B8 A3 v.25	DA	690		B8		A3		v.25
+PN 1995.9 .N3 N75 1970	PN	1995.9		N3		N75	1970	
+D570.3 28th .P96	D	570.3	28TH	P96				
+UA704 .C9 12 th R89	UA	704		C9	12th	R89		
+E517.5 21st .A54	E	517.5	21st	A54				
+D761.1 .1st L36	D	761.1	1st	L36				
+G 9801 .A4 s250 .G4 ST5-8/11	G	9801		A4		S250,G4		ST5-8/11
+HD 8039 .R52 I4 I42	HD	8039		R52		I4,I42		
+ND 623 .L58 A43 1970	ND	623		L58		A43	1970	
+DK265.8.L4 L573	DK	265.8		L4		L573		
+A1 1888 .B2 1990	A	1	1888	B2			1990	
+A1 B2 1888 1990	A	1		B2	1888		1990	
+A1 1888 B2 12th	A	1	1888	B2	12TH			
+A1 B2 1990 v.3	A	1		B2			1990	v.3

data/test/test_lc_callnumber.rb

@@ -0,0 +1,32 @@
+require 'minitest_helper'
+
+describe "Metadata" do
+  it "has a version number" do
+     assert ::LCCallNumber::VERSION
+  end
+end
+
+describe "Basics" do
+  it "can parse all the items in the basics file" do
+    File.open(test_data('basics.txt')).each_line do |line|
+      next if line =~ /\A#/
+      next unless line =~ /\S/
+      line.chomp!
+      orig,letters,digits,doon1,c1,doon2,other_cutters,pubyear,rest = line.split(/\t/).map{|s| s.upcase.strip.to_s}
+      lc = LCCallNumber.parse(orig)
+      assert_equal letters.to_s, lc.letters, "#{orig} -> letters #{lc.inspect}"
+      assert_equal digits.to_s, lc.digits.to_s, "#{orig} -> numbers #{lc.inspect}"
+      assert_equal doon1.to_s, lc.doon1.to_s, "#{orig} -> doon1 #{lc.inspect}"
+      assert_equal c1.to_s, lc.firstcutter.to_s, "#{orig} -> first cutter #{lc.inspect}"
+      assert_equal doon2.to_s, lc.doon2.to_s, "#{orig} -> doon2 #{lc.inspect}"
+      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
+      
+      
+      

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: lc_callnumber
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bill Dueber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Work with  LC Call (Classification) Numbers
+email:
+- bill@dueber.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lc_callnumber.gemspec
+- lib/lc_callnumber.rb
+- lib/lc_callnumber/lcc.rb
+- lib/lc_callnumber/parser.rb
+- lib/lc_callnumber/version.rb
+- test/minitest_helper.rb
+- test/test_data/basics.txt
+- test/test_lc_callnumber.rb
+homepage: https://github.com/billdueber/lc_callnumber
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Work with  LC Call (Classification) Numbers, including an attempt to parse
+  them out from a string to their component parts
+test_files:
+- test/minitest_helper.rb
+- test/test_data/basics.txt
+- test/test_lc_callnumber.rb