lcsort 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 830c39b4588cbf4efdc6ce8eb0f97ad0ae596d77
+  data.tar.gz: 760bb1182bdf2a660d364db668e64f0c80f4c88a
+SHA512:
+  metadata.gz: 4bd2881d4c1c9f7ab8c7ead44801005e2c703acb4767d588633e271acad1f3f51233524ae3b793661c015861094513f02c483898f628e9874b02bce63c559678
+  data.tar.gz: 955c2145684c114804e6e6a7b981ad48c240da3d49259eaeeda84004509845a1a71404b4b039d84783b7ff008653fdeea0db42af3df18af968fd15e4ec5c0ad9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+  - jruby-19mode

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015
+
+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,76 @@
+Normalized sort key for sorting Library of Congress call numbers. 
+
+## Usage
+
+Sorting Library of Congress call numbers is tricky. This library generates
+a sort key for a LC call number, such that for a list of callnums, their
+sort keys will sort (natural byte order) in the same order the call
+numbers should sort in. 
+
+    # It's often useful to store the sort_key in a db
+    sort_key = Lcsort.normalize(callnum)
+
+If the input can't be recognized as an LC Call Number, `nil` will be returned. 
+
+This code is intended for ascii-only input, if you have UTF-8 in your
+call numbers, we don't know what will happen. 
+
+    # Or if you have a list of call numbers in memory, easy
+    # enough to just sort them in memory:
+    call_num_array.sort_by {|callnum| Lcsort.normalize(callnum) }
+
+## We can handle all sorts of call numbers
+
+Call numbers are diverse, both in standard LC and local practice.
+We wouldn't have the hubris to say we can properly recognize and sort
+EVERY possible LC call number including local practices. But we sure
+can handle a lot, including:
+
+* Typical call numbers like:  `R 169.1 .B59 1990`
+* Can handle variations in spacing/punctuation, such as: `R 169.B59.C39`, `R169 B59C39 1990`
+* Can handle properly sorting the dreaded 'date or other number': `KF 4558 15th .G6` sorts after `KF 4558 1st .G6`
+* Will _generally_ sort volume/number info in call number suffix properly: `Q11 .P6  vol. 4 no. 4` sorts before `Q11 .P6 vol. 12 no. 1`. 
+* Can handle 1-2 letter suffixes on the end of cutters: `R 179 .C79ab`.  Common local practice, and also used in NLM call numbers. (No guarantee that every NLM call number can be handled by this library for LC call numbers, but it seems to work okay for NLM.)
+ 
+
+[OCLC's docs on MARC 050](http://www.oclc.org/bibformats/en/0xx/050.html) includes some information on possible LC call number components. 
+
+## Range and truncation limiting
+
+Once you have a bunch of Lcsort keys in your database, you may want to search
+to find all call numbers beginning with, say, `EG 101`.  So that might include `EG 101.5`, `EG 101 .C23 1990` etc.
+
+The `truncated_range_end` method gives you a proper ending range to get what you want, say:
+
+    sort_key >= #{Lcsort.normalize("EG 101")} AND sort_key <= #{Lcsort.truncated_range_end('EG 101')}
+
+This can also be used for finding a range of call numbers. Say you want all call numbers
+from those beginning with `AB 101` to `AB 500`:
+
+    sort_key >= #{Lcsort.normalize("AB 101")} AND sort_key <= #{Lcsort.truncated_range_end('AB 500')}
+
+`truncated_range_end` works with as many or as few call number components as you want. `Lcsort.truncated_range_end('AB 101.1')` will find `AB 101.123` or `AB 101.1 .A5` too. `Lcsort.truncated_range_end("AB 101 .C45")` will find `AB 101 .C456`, `AB 101 .C45 .B5`, etc. 
+
+At the moment, `truncated_range_end` actually pretty much just adds an `~` onto the end
+of the normalized sort key. But it did more complicated things in past versions of
+the normaliation algorithm, and we do have tests ensuring it finds what is expected. 
+
+## append_suffix
+
+Sometimes you want to add something on to the end of a normalized call number,
+as a payload, or to ensure normalized sort key uniqueness. 
+
+You can pass an :append_suffix to have it appended in a way that won't
+otherwise change the sort order of the original call number. 
+
+I use this to add the bib ID on to the end of the normalized sort key,
+because if two bibs have identical call numbers, I want to avoid 
+normalized sort key collision, because my functions work better with
+all unique sort keys. 
+
+     sortkey = Lcsort.normalize(callnumber, :append_suffix => bibID)
+
+## Acknowledgement
+
+Original regex and code by Bill Dueber. Original port to ruby by Nikitas Tampakis.
+LC handling advice from Naomi Dushay and her code. 

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lcsort"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lcsort.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lcsort/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lcsort"
+  spec.version       = Lcsort::VERSION
+  spec.authors       = ["Nikitas Tampakis", "Jonathan Rochkind"]
+  spec.email         = ["tampakis@princeton.edu"]
+
+  spec.summary       = %q{Sort-normalized forms of LC Call Numbers}
+  spec.description   = %q{Sort-order-normalize Library of Congress call numbers and determine search ranges for left-anchor search}
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/lcsort.rb

@@ -0,0 +1,257 @@
+# encoding: utf-8
+
+# The sorting code is organized as a class for code organization
+# and possible future parameterization. 
+#
+#     Lcsort.new.normalize(call)
+#
+# But for convenience and efficiency, you can call as a class method too:
+#
+#    Lcsort.normalize(call)
+class Lcsort
+  HIGH_CHAR = '~'
+
+  LC= /^
+      \s*
+      ([A-Z]{1,3})  # alpha
+      \s*
+      (?:         # optional numbers with optional decimal point
+        (\d+)     # num
+        (?:\s*?\.\s*?(\d+))?  # dec
+      )?
+      \s*
+      (?:         # optional doon1 -- date or other number eg 1991 , 103rd, 103d
+        \.?
+        (\d{1,4})
+        (?:ST|ND|RD|TH|D)?
+      )?
+      \s*
+      (?:               # optional cutter
+        \.? \s*
+        ([A-Z])      # cutter letter  c1alpha
+        # cutter numeric portion is optional entirely IF at end of string, to
+        # support bottomout on partial cutters
+        # optional cutter letter suffixes are also supported
+        # ie .A12ab -- which requires lookahead to make sure not absorbing subsequent
+        # cutter, doh.
+        \s*
+        (\d+                              # cutter numbers c1num
+          (?: [a-zA-Z]{0,2}(?=[ \.]|\Z))? # ...with optional 1-2 letter suffix
+        | \Z)
+      )?
+      \s*
+      (?:         # optional doon2 -- date or other number eg 1991 , 103rd, 103d
+        \.?
+        (\d{1,4})
+        (?:ST|ND|RD|TH|D)?
+      )?
+      \s*
+      (?:               # optional cutter
+        \.? \s*
+        ([A-Z])      # cutter letter  c2alpha
+        \s*
+        (\d+                              # cutter numbers c2num
+          (?: [a-zA-Z]{0,2}(?=[ \.]|\Z))? # ...with optional 1-2 letter suffix
+        | \Z)
+      )?
+      \s*
+      (?:               # optional cutter
+        \.? \s*
+        ([A-Z])      # cutter letter  c3alpha
+        \s*
+        (\d+                              # cutter numbers c3num
+          (?: [a-zA-Z]{0,2}(?=[ \.]|\Z))? # ...with optional 1-2 letter suffix
+        | \Z)
+      )?
+      (\s+.+?)?        # everthing else extra
+      \s*$/x
+
+
+  attr_accessor :alpha_width, :class_whole_width, :doon_width, :extra_vol_num_width
+  attr_accessor :low_prefix_separator, :cutter_extralow_separator, :class_letter_padding, :extra_separator, :append_suffix_separator
+  attr_accessor :extra_num_regexp
+
+  def initialize()
+    self.alpha_width       = 3
+    self.class_whole_width = 4
+    self.doon_width        = 4
+    self.extra_vol_num_width = 4
+
+    # cutter prefix separator must be lower ascii value than digit 0,
+    # but higher than cutter_extralow_separator. `.` gives us
+    # something that makes debugging easy and doesn't need to be
+    # URI-escaped, which is nice. 
+    self.low_prefix_separator       = '.'
+    # cutter extralow separator separates cutter letter suffixes
+    # ei as in the 'ab' A234ab. It must be LOWER ascii value than
+    # low_prefix_separator to make sort work. 
+    # Could use space ` `, but `-` is
+    # less confusing debugging and nice that it doesn't need to be URI-escaped. 
+    self.cutter_extralow_separator = '-'
+
+    # Using anything less than ascii 0 should work, but `.` is nice for
+    # debugging. 
+    self.class_letter_padding      = '.'
+
+    # Extra separator needs to be lower than our other separators,
+    # especially cutter_extralow_separator. 
+    # Doubling the cutter_extralow_separator works. 
+    self.extra_separator           = (self.cutter_extralow_separator * 2)
+
+    # Needs to sort LOWER than extra separator, at least in cases
+    # where there's no extra. We tried comma, but MySQL did weird
+    # things under utf8 collation. Let's see if it works better with
+    # three dashes.
+    self.append_suffix_separator   = (self.cutter_extralow_separator * 3)
+
+    # Only state should be configuration, not about individual call numbers. 
+    # We re-use this for multiple call numbers, and don't want callnum-specific
+    # state; we also want to ensure it's thread-safe for using between multiple
+    # threads. So freeze it! Doesn't absolutely prevent state changes, but
+    # helps and sends the message. 
+    self.freeze
+  end
+
+
+  # Our code is organized in a class, for code organization and
+  # possibility of sub-class and constructor customization in the future. 
+  #
+  # But most people will want to call as a simple class-method. 
+  # Store a singleton instance of Lcsort to let class method
+  # be efficient and not need to instantiate a new one every time. 
+  #
+  # Initialize singleton NOT lazily but here on class def, for
+  # thread safety. 
+  @global = Lcsort.new
+  def self.normalize(*args)
+    @global.normalize(*args)
+  end
+
+  def self.truncated_range_end(*args)
+    @global.truncated_range_end(*args)
+  end
+
+  def normalize(cn, options = {})
+    callnum = cn.upcase
+
+    match = LC.match(callnum)
+    unless match
+      return nil
+    end
+
+    alpha, num, dec, doon1, c1alpha, c1num, doon2, c2alpha, c2num, c3alpha, c3num, extra = match.captures
+
+
+    # We can't handle a class number wider than the space we have
+    if num && num.length > self.class_whole_width
+      return nil
+    end
+
+    normal_str = ""
+
+    # Right fill alpha class with separators, to ensure sort, we
+    # always have alpha.
+    normal_str << right_fill( alpha, alpha_width,        self.class_letter_padding)
+
+    # Left-fill whole number with preceding 0's to ensure sort,
+    # Only needed if present, sort will work right regardless.
+    if num
+      normal_str << left_fill_number(num, class_whole_width)
+    end
+
+    # decimal class number needs no fill, add it if we have it.
+    # relies on fixed width whole number to sort properly.
+    normal_str << dec  if dec
+
+    # Add cutters and doons in order, if present
+    normal_str << normalize_doon(doon1) if doon1
+    
+    normal_str << normalize_cutter(c1alpha, c1num) if c1alpha
+
+    normal_str << normalize_doon(doon2) if doon2
+
+    normal_str << normalize_cutter(c2alpha, c2num) if c2alpha
+    normal_str << normalize_cutter(c3alpha, c3num) if c3alpha
+
+    normal_str << normalize_extra(extra)           if extra
+
+    normal_str << normalize_append_suffix(options[:append_suffix]) if options[:append_suffix]
+
+    # normally we REQUIRE an alpha and number for a good call number,
+    # but for creating truncated_end_ranges, we relax that. 
+    unless options[:range_end_construction]
+      unless alpha && num
+        return nil
+      end
+    end
+
+    return normal_str 
+  end
+
+  def truncated_range_end(callnum)
+    # Tell normalize to relax it's restrictions for range_end
+    # construction. 
+    normalized = normalize(callnum, :range_end_construction => true)
+
+    return nil unless normalized
+
+    # We just add a HIGH_CHAR on the end to make sure this sorts
+    # after the original normalized with ANYTHING else on the end. 
+    return normalized + HIGH_CHAR
+  end
+
+  def right_fill(content, width, padding)
+    content = content.to_s
+    fill_spots = width - content.length
+    fill_spots = 0 if fill_spots < 0
+
+    content.to_s + (padding * fill_spots)
+  end
+
+  # Left-pad a whole number with zeroes to specified width
+  def left_fill_number(content, width)
+    content = content.to_s
+    fill_spots = width - content.length
+    fill_spots = 0 if fill_spots < 0
+
+    return ('0' * fill_spots) + content 
+  end
+
+  def normalize_cutter(c_alpha_prefix, c_rest)
+    return nil if c_alpha_prefix.nil? || c_rest.nil?
+
+    # Put a low separator before alpha suffix if present, to
+    # ensure sort.
+    c_rest = c_rest.sub(/(.*\d)([a-zA-Z]{1,2})\Z/, "\\1#{self.cutter_extralow_separator}\\2")
+
+    self.low_prefix_separator + c_alpha_prefix + c_rest
+  end
+
+  def normalize_doon(doon)
+    return nil if doon.nil?
+
+    self.low_prefix_separator + left_fill_number(doon, self.doon_width)
+  end
+
+  # The 'extra' component is normalized by making it all alphanumeric,
+  # and adding an ultra low prefix separator. 
+  def normalize_extra(extra)
+    # Left-pad any volume/number type designations with zeros, so
+    # they sort appropriately.  We just find ALL numbers and
+    # normalize them accordingly, it's good enough! 
+    extra_normalized = extra.gsub(/(\d+)/) do |match|
+      left_fill_number($1, self.extra_vol_num_width)      
+    end
+
+    # remove all non-alphanumeric
+    extra_normalized = extra_normalized.gsub(/[^A-Z0-9]/, '')
+
+    # Add very low prefix separator
+    return (self.extra_separator + extra_normalized)
+  end
+
+  def normalize_append_suffix(suffix)
+    self.append_suffix_separator + suffix
+  end
+
+end

data/lib/lcsort/version.rb

@@ -0,0 +1,3 @@
+class Lcsort
+  VERSION = "0.9.0"
+end

data/lib/lcsort/volume_abbreviations.rb

@@ -0,0 +1,216 @@
+require 'lcsort'
+
+class Lcsort
+  # Volume-type abbreviations used in call numbers, taken from
+  # https://www.libraries.psu.edu/psul/cataloging/catref/callnumbers/callterms.html
+  #
+  # We create an array of them, just the abbreviations without the periods,
+  # normalized to upcase. 
+  #
+  # We also add a few more. 
+  #
+  # This is used for left-padding vol/num numbers with 0's in the 'extra',
+  # So they sort properly. 
+
+
+  abbrevs = [
+    'Abh', # Abhandlung
+    'Abs', # Abschnitt
+    'abstr', # abstracts
+    'Abt', # Abteilung, Abtheilung
+    'addendum', #addendum
+    'addit', # additamenta (Latin)
+    'afd', # afdeling
+    'afl', # aflevering
+    'anejo', # anejo
+    'anexo', # annexo
+    'annex', # annex
+    'appx', #appendix
+    'ar', #arithmos (Greek)
+    'arg', # argang
+    'atlas', # atlas
+    'aux', # auxiliary
+    'avd', # avdeling
+     
+
+    'Bdchn', # Bandchen
+    'Bde', # Bande
+    'Bd', #Band (German)
+    'bd', #band (Swedish), b'and (Yiddish)
+    'bk', #book
+    'bklet', # booklet
+    'Buch', #Buch
+     
+
+    'canto', # canto
+    'cart', #cartridge
+    'cs', #cassette
+    'c', # cast
+    'chap', #chapter [1]
+    'charts', #charts
+    'ch', #chast', chastyna
+    'cis', # cislo
+    'class', # class
+    'comment', # commentarium, commentaries
+    'cong', #congress
+    'cz', #czesc
+     
+
+    'd', # disc
+    'dala', #dala
+    'dalis', # dalis
+    'deel', #deel [2]
+    'del', # del [2]
+    'deo', # deo
+    'dial', #dial
+    'diel', #diel
+    'dil', # dil
+    'dzel', #dzel
+     
+
+    'ed', #edition
+    'Ergbd', # Erganzungsband
+    'Erghft', #Erganzungsheft
+     
+
+    'F', # Folge
+    'fasc', #fascicle, fasciculus
+    'Fasz', #Faszikel
+     
+
+    'g', # godina
+    'Gesamtausg', #Gesamtausgabe
+    'graphs', #graphs
+    'guide', # guide
+     
+
+    'hft', # hafte (Swedish)
+    'Halbbd', #Halbband
+    'halvbd', #halvband (Swedish)
+    'handbk', #handbook
+    'Hft', # Heft
+    'hov',  # hoveret (Hebrew)
+     
+
+    'illus', # illustration, -s [3]
+    'index', # index
+    'intro', # introduction [4]
+     
+
+    'jaarg', # jaargang
+    'Jahrg', # Jahrgang
+    'Jahrhdt', # Jahrhundert
+     
+
+    'Kap', # Kapitel
+    'kn', #kniga, kniha
+    'knj', # knjiga
+    'koide', # koide
+    'kommentar', # kommentar
+    'kot', # kotet
+     
+
+    'Lfg', # Lieferung
+    'livr', #livraison
+    'livre', # livre
+     
+
+    'maj', # major
+    'manual', #manual
+    'maps', #maps
+    'med', # medium
+    'min', # minor
+    'module', #module
+    'ms\'', # mispar (Yiddish)
+     
+
+    'n.F', # neue Folge
+    'n.s', # new series, nuova serie,nova serie, nueva serie [5]
+    'nom', # nomer
+    'nouv', #nouveau, nouvelle
+    'no', #number, -s, numero (French), numero (Spanish)
+    'nr', #numer
+    'n', # numero (Italian)
+    'n:o', # numero (Finnish)
+    'Nr', #Nummer
+    'nr', #nummer
+     
+
+    'op', #opus
+    'osa', # osa
+    'osat', #osat (Finnish)
+    'otd', # otdel, otdelenie
+     
+
+    'pars', #pars
+    'pt', 
+    'pts', #part, -s
+    'pt', #parte
+    'ptie', #partie
+    'p', # pik
+    'plates', #plates
+    'portfolio', # [6] portfolio
+    'prelim', #preliminary
+     
+
+    'qtr', # quarter
+     
+
+    'reel', #reel
+    'rept', #report
+    'rev', # revised, revision
+    'r', # rik
+    'roc', # rocnik
+    'rocz', #rocznik
+    'r', # rok
+     
+
+    'Samml', # Sammlung
+    'sect', #section
+    'sejums', #sejums
+    'ser', # serie, series
+    'ses', # sesit
+    'sess', #session
+    'study', # study
+    'sub', # subject
+    'suppl', # supplement
+    'sv', #svazek, svazok, sveska, svezak
+    'sz', #szam
+     
+
+    'tables', #tables
+    'T', # Teil, Theil
+    'Tbd', # Teilband
+    'theme', # theme
+    'title', # title
+    'Titel', # Titel (German)
+    't', # tom, tome, tomo, tomos, tomus
+    'tl', #tayl, tiyl (Yiddish)
+     
+
+    'Uabs', #Unterabschnitt
+     
+
+    'v', # volume, -s
+    'vol', # volumul
+    'Vorber', #Vorbericht
+    'vyp', # vypusk
+     
+
+    'workbk', #workbook
+     
+
+    'yaarg', # yaargang (Hebrew)
+     
+
+    'zesz', #zeszyt
+    'zosh', #zoshyt
+    'zv', #zvazok, zvezek
+  ]
+  abbrevs = abbrevs.collect {|a| a.upcase}
+
+  abbrevs << "K"  # Mozart Kochel catalog number
+
+  VolumeAbbreviations = abbrevs
+
+end

data/rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: lcsort
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Nikitas Tampakis
+- Jonathan Rochkind
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Sort-order-normalize Library of Congress call numbers and determine search
+  ranges for left-anchor search
+email:
+- tampakis@princeton.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/setup
+- lcsort.gemspec
+- lib/lcsort.rb
+- lib/lcsort/version.rb
+- lib/lcsort/volume_abbreviations.rb
+- rakefile
+homepage: 
+licenses: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Sort-normalized forms of LC Call Numbers
+test_files: []