library_stdnums 0.3.0 → 1.0.0

data/README.markdown

@@ -0,0 +1,92 @@
+# library_stdnums -- simple functions to check and normalize ISSN/ISBN/LCCN
+
+These are a set of Module functions (not classes with methods!) that perform simple checksum verification and (when applicable) normalization on strings containing common library types (currently just ISBN, ISSN, and LCCN).
+
+The code allows for some minimal crap (e.g., '1234-4568 online') will work fine. All returned ISBN/ISSN values are devoid any dashes; any trailing X for an ISBN/ISSN checkdigit will be uppercase *and will always be returned as a one-digit string*. 
+
+See the actual functions for more information than what's below.
+
+## ISBN
+
+````ruby
+  isbn = StdNum::ISBN.normalize(goodISBN)
+    # => a 13-digit ISBN with no dashes/spaces
+    
+  isbn = StdNum::ISBN.normalize(badISBN)
+    # => nil (if it's not an ISBN or the checkdigit is bad)
+  
+  tenDigit = StdNum::ISBN.convert_to_10(isbn13)
+  thirteenDigit = StdNum::ISBN.convert_to_13(isbn10)
+  
+  thirteenDigit,tenDigit = StdNum::ISBN.allNormalizedValues(issn)
+    # => array of the ten and thirteen digit isbns if valid; 
+    #    an empty array if not
+  
+  digit = StdNum::ISBN.checkdigit(isbn)
+    # => 0..9 (for isbn13) or 0..9,X (for isbn10)
+  
+  if StdNum::ISBN.valid?(isbn)
+    puts "#{isbn} has a valid checkdigit"
+  end
+  
+````
+
+# ISSN
+
+````ruby
+  issn = StdNum::ISSN.normalize(issn)
+  #  => the cleaned-up issn if valid; nil if not
+  
+  digit = StdNum::ISSN.checkdigit(issn)
+  #  => 0..9 or X
+
+  if StdNum::ISSN.valid?(issn)
+    puts "#{issn} has a valid checkdigit"
+  end
+````
+  
+# LCCN
+
+LCCNs are normalized according to the algorithm at http://www.loc.gov/marc/lccn-namespace.html#syntax
+
+````ruby
+
+  lccn = StdNum::LCCN.normalize(rawlccn)
+  #  => either the normalized lccn, or nil if it has bad syntax
+  
+  if StdNum::LCCN.valid?(rawlccn) {
+    puts "#{rawlccn} is valid"
+  }
+````
+
+== CHANGES
+
+* 1.0.0
+  * Added normalization all around. 
+  * Added valid? for LCCN. 
+  * Cleaner code all around, and better docs.
+* 0.3.0
+  * Wow. ISBN-13 checkdigit wasn't changing '10' to '0'. Blatant error; bad coding *and* testing.
+* 0.2.2
+  * Added ISSN.valid?
+  * Fixed error in ISSN.checksum when checksum was zero (was returning integer instead of string '0')
+* 0.2.1
+  * Oops. Forgot to check to make sure there are *any* digits in the ISBN. fixed.
+* 0.2.0
+  * Added allNormalizedValues for ISBN
+* 0.1.0 
+  * Initial release
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Bill Dueber. See LICENSE for details.

data/Rakefile

@@ -10,7 +10,7 @@ begin
     gem.email = "bill@dueber.com"
     gem.homepage = "http://github.com/billdueber/library_stdnums"
     gem.authors = ["Bill Dueber"]
-    gem.add_development_dependency "bacon", ">= 0"
+    gem.add_development_dependency "minitest", ">= 0" if RUBY_VERSION < "1.9"
     gem.add_development_dependency "yard", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.3.0
+1.0.0

data/lib/library_stdnums.rb

@@ -1,30 +1,53 @@
 module StdNum
-  
-  STDNUMPAT = /^.*?(\d[\d\-]+[xX]?)/
-  
-  # Extract the most likely looking number from the string. This will be the first
-  # string of digits-and-hyphens-and-maybe-a-trailing-X, with the hypens removed
-  def self.extractNumber str
-    match = STDNUMPAT.match str
-    return nil unless match
-    return match[1].gsub(/\-/, '').upcase
-  end
     
+  module Helpers
+    
+    STDNUMPAT = /^.*?(\d[\d\-]+[xX]?)/
 
+    # Extract the most likely looking number from the string. This will be the first
+    # string of digits-and-hyphens-and-maybe-a-trailing-X, with the hypens removed
+    def extractNumber str
+      match = STDNUMPAT.match str
+      return nil unless match
+      return match[1].gsub(/\-/, '').upcase
+    end
+    
+    def reduce_to_basics rawnum, valid_sizes = nil
+      return nil if rawnum.nil?
+      
+      num = extractNumber rawnum
+      
+      # Does it even look like a number?
+      return nil unless num
+      
+      # Return what we've got if we don't care about the size
+      return num unless valid_sizes
+      
+      # Check for valid size(s)
+      [valid_sizes].flatten.each do |s|
+        return num if num.size == s
+      end
+      
+      # Didn't check out size-wise. Return nil
+      return nil
+    end
+  end
+    
 
   module ISBN
+    extend Helpers
   
     # Compute check digits for 10 or 13-digit ISBNs. See algorithm at
     # http://en.wikipedia.org/wiki/International_Standard_Book_Number
     # @param [String] isbn The ISBN (we'll try to clean it up if possible)
-    # @return [String] the one-character checkdigit
-    def self.checkdigit isbn
-      isbn = StdNum.extractNumber isbn
+    # @param [Boolean] preprocessed Set to true if the ISBN has already been through reduce_to_basics
+    # @return [String,nil] the one-character checkdigit, or nil if it's not an ISBN string
+    def self.checkdigit isbn, preprocessed = false
+      isbn = reduce_to_basics isbn, [10,13] unless preprocessed
       return nil unless isbn
-      size = isbn.size
-      return nil unless size == 10 or size == 13
+
       checkdigit = 0
-      if size == 10
+      if isbn.size == 10
         digits = isbn[0..8].split(//).map {|i| i.to_i}
         (1..9).each do |i|
           checkdigit += digits[i-1] * i
@@ -47,66 +70,83 @@ module StdNum
     
     # Check to see if the checkdigit is correct
     # @param [String] isbn The ISBN (we'll try to clean it up if possible)
+    # @param [Boolean] preprocessed Set to true if the ISBN has already been through reduce_to_basics
     # @return [Boolean] Whether or not the checkdigit is correct
-    def self.valid? isbn
-      isbn = StdNum.extractNumber isbn
+    def self.valid? isbn, preprocessed = false
+      return nil if isbn.nil?
+      isbn = reduce_to_basics(isbn, [10,13]) unless preprocessed
       return false unless isbn
-      size = isbn.size
-      return false unless (size == 10 or size == 13)
-      return isbn[-1..-1] == self.checkdigit(isbn)
+      return false unless isbn[-1..-1] == self.checkdigit(isbn, true)
+      return true
     end
   
+    
+    # For an ISBN normalizing it is the same as converting to ISBN 13
+    # and making sure it's valid
+    # @param [String] isbn The ISBN to normalize
+    # @param [Boolean] passthrough On failure, return the original passed-in value instead of nil
+    # @return [String, nil] the normalized (to 13 digit) ISBN, or nil on failure
+    def self.normalize rawisbn
+      isbn = convert_to_13 rawisbn
+      if isbn and valid?(isbn, true)
+        return isbn
+      else
+        return nil
+      end
+    end
+      
     # To convert to an ISBN13, throw a '978' on the front and 
     # compute the checkdigit
-    # We leave 13-digit numbers alone, figuring they're already ok,
+    # We leave 13-digit numbers alone, figuring they're already ok. NO CHECKSUM CHECK IS DONE FOR 13-DIGIT ISBNS!
     # and return nil on anything that's not the right length
     # @param [String] isbn The ISBN (we'll try to clean it up if possible)
-    # @return [String] The converted 13-character ISBN, nil if something looks wrong, or whatever was passed in if it already looked like a 13-digit ISBN
+    # @return [String, nil] The converted 13-character ISBN, nil if something looks wrong, or whatever was passed in if it already looked like a 13-digit ISBN
     def self.convert_to_13 isbn
-      isbn = StdNum.extractNumber isbn
+      isbn = reduce_to_basics isbn, [10,13]
       return nil unless isbn
-      size = isbn.size
-      return isbn if size == 13
-      return nil unless size == 10
-    
+      return isbn if isbn.size == 13
       prefix = '978' + isbn[0..8]
-      return prefix + self.checkdigit(prefix + '0')
+      return prefix + self.checkdigit(prefix + '0', true)
     end
-    
-    
+
+
     # Convert to 10 if it's 13 digits and the first three digits are 978.
     # Pass through anything 10-digits, and return nil for everything else.
     # @param [String] isbn The ISBN (we'll try to clean it up if possible)
     # @return [String] The converted 10-character ISBN, nil if something looks wrong, or whatever was passed in if it already looked like a 10-digit ISBN
     def self.convert_to_10 isbn
-      isbn = StdNum.extractNumber isbn
-      return nil unless isbn
-      size = isbn.size
-      return isbn if size == 10
-      return nil unless size == 13
+      isbn = reduce_to_basics isbn, [10,13]
+
+      # Already 10 digits? Just return
+      return isbn if isbn.size == 10
+      
+      # Can't be converted to ISBN-10? Bail
       return nil unless isbn[0..2] == '978'
       
       prefix = isbn[3..11]
       return prefix + self.checkdigit(prefix + '0')
     end
     
-    # Return an array of the ISBN10 and ISBN13 for the passed in value. You'll
+    # Return an array of the ISBN13 and ISBN10 (in that order) for the passed in value. You'll
     # only get one value back if it's a 13-digit
     # ISBN that can't be converted to an ISBN10.
     # @param [String] isbn The original ISBN, in 10-character or 13-digit format
-    # @return [Array] Either the (one or two) normalized ISBNs, or an empty array if
+    # @return [Array<String,String>, nil] Either the (one or two) normalized ISBNs, or nil if
     # it can't be recognized.
+    #
+    # @example Get the normalized values and index them (if valid) or original value (if not)
+    #   norms = StdNum::ISBN.allNormalizedValues(rawisbn)
+    #   doc['isbn'] = norms ? norms : [rawisbn]
+    
     
     def self.allNormalizedValues isbn
-      isbn = StdNum.extractNumber isbn
+      isbn = reduce_to_basics isbn, [10,13]
       return [] unless isbn
       case isbn.size
       when 10
-        return [isbn, self.convert_to_13(isbn)]
+        return [self.convert_to_13(isbn), isbn]
       when 13
         return [isbn, self.convert_to_10(isbn)].compact
-      else
-        return []
       end
     end
     
@@ -114,13 +154,17 @@ module StdNum
   end
   
   module ISSN
+    extend Helpers
     
     # Compute the checkdigit of an ISSN
     # @param [String] issn The ISSN (we'll try to clean it up if possible)
+    # @param [Boolean] preprocessed Set to true if the number has already been through reduce_to_basic    
     # @return [String] the one-character checkdigit
-    def self.checkdigit issn
-      issn = StdNum.extractNumber issn
-      return nil unless issn and issn.size == 8
+    
+    def self.checkdigit issn, preprocessed = false
+      issn = reduce_to_basics issn, 8 unless preprocessed
+      return nil unless issn
+
       digits = issn[0..6].split(//).map {|i| i.to_i}
       checkdigit = 0
       (0..6).each do |i|
@@ -135,32 +179,93 @@ module StdNum
     
     # Check to see if the checkdigit is correct
     # @param [String] isbn The ISSN (we'll try to clean it up if possible)
+    # @param [Boolean] preprocessed Set to true if the number has already been through reduce_to_basic        
     # @return [Boolean] Whether or not the checkdigit is correct
-    def self.valid? issn
-      issn = StdNum.extractNumber issn
+
+    def self.valid? issn, preprocessed = false
+      issn = reduce_to_basics issn, 8 unless preprocessed
       return false unless issn
-      size = issn.size
-      return false unless (size == 8)
-      return issn[-1..-1] == self.checkdigit(issn)
+      return issn[-1..-1] == self.checkdigit(issn, true)
     end
     
+    def self.normalize rawissn
+      issn = reduce_to_basics rawissn, 8
+      if issn and valid?(issn, true)
+        return issn
+      else
+        return nil
+      end
+    end
+      
+    
     
   end
   
   module LCCN
+    
+    # The rules for validity according to http://www.loc.gov/marc/lccn-namespace.html#syntax:
+    #
+    # A normalized LCCN is a character string eight to twelve characters in length. (For purposes of this description characters are ordered from left to right -- "first" means "leftmost".)
+    # The rightmost eight characters are always digits. 
+    # If the length is 9, then the first character must be alphabetic.
+    # If the length is 10, then the first two characters must be either both digits or both alphabetic.
+    # If the length is 11, then the first character must be alphabetic and the next two characters must be either both digits or both alphabetic.
+    # If the length is 12, then the first two characters must be alphabetic and the remaining characters digits.
+    #
+    # @param [String] lccn The lccn to attempt to validate
+    # @param [Boolean] preprocessed Set to true if the number has already been normalized   
+    # @return [Boolean] Whether or not the syntax seems ok
+
+    def self.reduce_to_basic str
+      str.gsub!(/\s/, '') # ditch leading spaces
+      str.gsub!(/\/.*$/, '') # ditch everything after the first '/' (including the slash)
+      return str
+    end
+      
+
+    def self.valid? lccn, preprocessed = false
+      lccn = normalize(lccn) unless preprocessed
+      return false unless (8..12).include? lccn.size
+      clean = lccn.gsub(/\-/, '')
+      suffix = clean[-8..-1]
+      prefix = clean[0..-9]
+      return false unless suffix =~ /^\d+$/
+      case clean.size
+      when 8
+        return true
+      when 9
+        return true if prefix =~ /[A-Za-z]/
+      when 10
+        return true if prefix =~ /\d{2}/ or prefix =~ /[A-Za-z]{2}/
+      when 11
+        return true if prefix =~ /[A-Za-z](\d{2}|[A-Za-z]{2})/
+      when 12
+        return true if prefix =~ /[A-Za-z]{2}\d{2}/
+      else
+        return false
+      end
+    end
+
+    
+    
     # Normalize based on data at http://www.loc.gov/marc/lccn-namespace.html#syntax
     # @param [String] str The LCCN to normalize
     # @return [String] the normalized LCCN, or nil if it looks malformed
-    def self.normalize str
-      str.gsub!(/\s/, '')
-      str.gsub!(/\/.*$/, '')
-      if str =~ /^(.*?)\-(.+)/
+    def self.normalize rawlccn
+      lccn = reduce_to_basic(rawlccn)      
+      # If there's a dash in it, deal with that.
+      if lccn =~ /^(.*?)\-(.+)/
         pre =  $1
         post = $2
         return nil unless post =~ /^\d+$/ # must be all digits
-        return "%s%06d" % [pre, post.to_i]
+        lccn = "%s%06d" % [pre, post.to_i]
+      end
+      
+      if valid?(lccn, true)
+        return lccn
+      else
+        return nil
       end
-      return str
     end
   end  
   

data/spec/library_stdnums_spec.rb

@@ -2,31 +2,31 @@ require 'spec_helper'
 
 describe "Extract" do
   it "should leave a number alone" do
-    StdNum.extractNumber('123456').should.equal '123456'
+    StdNum::ISBN.extractNumber('123456').must_equal '123456'
   end
   
   it "should skip leading and trailing crap" do
-    StdNum.extractNumber(' 12345 (online)').should.equal '12345'
+    StdNum::ISBN.extractNumber(' 12345 (online)').must_equal '12345'
   end
   
   it "should allow hyphens" do
-    StdNum.extractNumber(' 1-234-5').should.equal '12345'
+    StdNum::ISBN.extractNumber(' 1-234-5').must_equal '12345'
   end
   
   it "should return nil on a non-match" do
-    StdNum.extractNumber('bill dueber').should.equal nil
+    StdNum::ISBN.extractNumber('bill dueber').must_equal nil
   end
   
   it "should allow a trailing X" do 
-    StdNum.extractNumber('1-234-5-X').should.equal '12345X'
+    StdNum::ISBN.extractNumber('1-234-5-X').must_equal '12345X'
   end
   
   it "should upcase any trailing X" do
-    StdNum.extractNumber('1-234-x').should.equal '1234X'
+    StdNum::ISBN.extractNumber('1-234-x').must_equal '1234X'
   end
   
   it "only allows a single trailing X" do
-    StdNum.extractNumber('1234-X-X').should.equal '1234X'
+    StdNum::ISBN.extractNumber('1234-X-X').must_equal '1234X'
   end
   
 end
@@ -34,52 +34,52 @@ end
 
 describe "ISBN" do
   it "computes 10-digit checksum" do
-    StdNum::ISBN.checkdigit('0-306-40615-X').should.equal '2'
+    StdNum::ISBN.checkdigit('0-306-40615-X').must_equal '2'
   end
   
   it "correctly uses X for checksum" do
-    StdNum::ISBN.checkdigit('061871460X').should.equal 'X'
+    StdNum::ISBN.checkdigit('061871460X').must_equal 'X'
   end
   
   it "finds a zero checkdigit" do
-    StdNum::ISBN.checkdigit('0139381430').should.equal '0'
+    StdNum::ISBN.checkdigit('0139381430').must_equal '0'
   end
   
   it "computes 13-digit checksum" do
-    StdNum::ISBN.checkdigit('9780306406157').should.equal '7'
+    StdNum::ISBN.checkdigit('9780306406157').must_equal '7'
   end
   
   it "computes a 13-digit checksum that is 0" do
-    StdNum::ISBN.checkdigit('9783837612950').should.equal '0'
+    StdNum::ISBN.checkdigit('9783837612950').must_equal '0'
   end
   
   it "finds a good number valid" do
-    StdNum::ISBN.valid?('9780306406157').should.equal true
+    StdNum::ISBN.valid?('9780306406157').must_equal true
   end
   
   it "finds a bad number invalid" do
-    StdNum::ISBN.valid?('9780306406154').should.equal false
+    StdNum::ISBN.valid?('9780306406154').must_equal false
   end
   
   it "returns nil when computing checksum for bad ISBN" do
-    StdNum::ISBN.checkdigit('12345').should.equal nil
+    StdNum::ISBN.checkdigit('12345').must_equal nil
   end
   
   it "converts 10 to 13" do
-    StdNum::ISBN.convert_to_13('0-306-40615-2').should.equal '9780306406157'
+    StdNum::ISBN.convert_to_13('0-306-40615-2').must_equal '9780306406157'
   end
   
   it "passes through 13 digit number instead of converting to 13" do
-    StdNum::ISBN.convert_to_13('9780306406157').should.equal '9780306406157'
+    StdNum::ISBN.convert_to_13('9780306406157').must_equal '9780306406157'
   end
   
   it "converts 13 to 10" do 
-    StdNum::ISBN.convert_to_10('978-0-306-40615-7').should.equal '0306406152'
+    StdNum::ISBN.convert_to_10('978-0-306-40615-7').must_equal '0306406152'
   end
   
   it "gets both normalized values" do
     a = StdNum::ISBN.allNormalizedValues('978-0-306-40615-7')
-    a.sort.should.equal ['9780306406157', '0306406152' ].sort
+    a.sort.must_equal ['9780306406157', '0306406152' ].sort
   end
   
   
@@ -90,7 +90,11 @@ end
 
 describe 'ISSN' do
   it "computes checksum" do 
-    StdNum::ISSN.checkdigit('0378-5955').should.equal '5'
+    StdNum::ISSN.checkdigit('0378-5955').must_equal '5'
+  end
+  
+  it "normalizes" do
+    StdNum::ISSN.normalize('0378-5955').must_equal '03785955'
   end
 end
 
@@ -106,12 +110,12 @@ describe 'LCCN' do
     "85-2 " => "85000002",
     "2001-000002" => "2001000002",
     "75-425165//r75" => "75425165",
-    " 79139101 /AC/r932" => "79139101"
+    " 79139101 /AC/r932" => "79139101",    
   }
   
   test.each do |k, v|
     it "normalizes #{k}" do
-      StdNum::LCCN.normalize(k.dup).should.equal v
+      StdNum::LCCN.normalize(k.dup).must_equal v
     end
   end
   

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
 require 'rubygems'
-require 'bacon'
 begin
-  require 'greeneggs'
+  gem 'minitest'
 rescue LoadError
 end
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
 require 'library_stdnums'
 
-Bacon.summary_on_exit

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: library_stdnums
 version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 0
-  version: 0.3.0
+  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors: 
 - Bill Dueber
@@ -15,37 +10,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-11 00:00:00 -04:00
+date: 2011-05-06 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: bacon
+  name: yard
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: yard
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id002
 description: Normalization and checksum computation for ISBN (10 and 13), ISSN, and LCCN
 email: bill@dueber.com
 executables: []
@@ -54,13 +32,11 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - .document
-- .gitignore
-- CHANGES
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
 - lib/library_stdnums.rb
@@ -71,8 +47,8 @@ homepage: http://github.com/billdueber/library_stdnums
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -80,26 +56,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Normalize and compute checkdigits for ISBN, ISSN, and LCCN
-test_files: 
-- spec/library_stdnums_spec.rb
-- spec/spec_helper.rb
+test_files: []
+

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/CHANGES

@@ -1,9 +0,0 @@
-0.3.0
-  Wow. ISBN-13 checkdigit wasn't changing '10' to '0'. Blatant error; bad coding *and* testing.
-0.2.2
-  Added ISSN.valid?
-  Fixed error in ISSN.checksum when checksum was zero (was returning integer instead of string '0')
-0.2.1
-  Oops. Forgot to check to make sure there are *any* digits in the ISBN. fixed.
-0.2.0
-  Added allNormalizedValues for ISBN

data/README.rdoc

@@ -1,23 +0,0 @@
-= library_stdnums
-
-Do common operations on ISBNs, ISSN, and LCCNs.
-
-What's supported:
-
-* *ISBN* Compute or validate checkdigit; convert to/from ISBN-10 and ISBN-13
-* *ISSN* Compute or validate checkdigit
-* *LCCN* Normalize
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Bill Dueber. See LICENSE for details.