lisbn 0.2.3 → 0.3.2

data/lib/lisbn/cache_method.rb

@@ -5,7 +5,7 @@ class Lisbn < String
         alias_method method + "_without_cache", method
         define_method method do |*args, &blk|
           @cache ||= {}
-          @cache[[method, self]] ||= send(method + "_without_cache", *args, &blk)
+          @cache[[method, args, blk, self]] ||= send(method + "_without_cache", *args, &blk)
         end
       end
     end

data/lib/lisbn/lisbn.rb

@@ -17,8 +17,10 @@ class Lisbn < String
   end
 
   def isbn_with_dash
-    if valid_isbn_13? && parts
-      parts.join("-")
+    if valid_isbn_13? && parts5 = parts(5)
+      parts5.join("-")
+    elsif valid_isbn_10? && parts4 = parts(4)
+      parts4.join("-")
     elsif isbn.length > 3
       isbn[0..-2] + "-" + isbn[-1]
     else
@@ -45,18 +47,21 @@ class Lisbn < String
     '978' + isbn[0..-2] + isbn_13_checksum
   end
 
-  # Returns an Array with the 'parts' of the ISBN-13 in left-to-right order.
+  # Returns an Array with the 'parts' of the ISBN in left-to-right order.
   # The parts of an ISBN are as follows:
-  #   - GS1 prefix
+  #   - GS1 prefix (only for ISBN-13)
   #   - Group identifier
   #   - Prefix/publisher code
   #   - Item number
   #   - Check digit
   #
   # Returns nil if the ISBN is not valid.
+  # Returns nil if parts argument is 4 but ISBN-10 does not exist
   # Returns nil if the group and prefix cannot be identified.
-  def parts
+  def parts(parts = 5)
+    raise ArgumentError, "Parts must be either 4 or 5." unless parts == 4 || parts == 5
     return unless isbn13
+    return if parts == 4 && !isbn10
 
     group = prefix = nil
 
@@ -80,36 +85,59 @@ class Lisbn < String
     return unless group && prefix
 
     prefix = sprintf("%0#{prefix[:length]}d", prefix[:number])
-    [group[0..2], group[3..-1], prefix, isbn13[(group.length + prefix.length)..-2], isbn13[-1..-1]]
+
+    if parts == 4
+      [group[3..-1], prefix, isbn10[(group[3..-1].length + prefix.length)..-2], isbn10[-1..-1]]
+    else
+      [group[0..2], group[3..-1], prefix, isbn13[(group.length + prefix.length)..-2], isbn13[-1..-1]]
+    end
   end
 
   def isbn_10_checksum
     base = isbn.length == 13 ? isbn[3..-2] : isbn[0..-2]
 
-    products = base.each_char.each_with_index.map do |chr, i|
-      chr.to_i * (10 - i)
-    end
+    sum = base[0].to_i * 10 +
+          base[1].to_i *  9 +
+          base[2].to_i *  8 +
+          base[3].to_i *  7 +
+          base[4].to_i *  6 +
+          base[5].to_i *  5 +
+          base[6].to_i *  4 +
+          base[7].to_i *  3 +
+          base[8].to_i *  2
+
+    remainder = sum % 11
 
-    remainder = products.inject(0) {|m, v| m + v} % 11
     case remainder
       when 0
-        0
+        "0"
       when 1
-        'X'
+        "X"
       else
-        11 - remainder
-    end.to_s
+        (11 - remainder).to_s
+    end
   end
 
   def isbn_13_checksum
     base = (isbn.length == 13 ? '' : '978') + isbn[0..-2]
 
-    products = base.each_char.each_with_index.map do |chr, i|
-      chr.to_i * (i % 2 == 0 ? 1 : 3)
-    end
-
-    remainder = products.inject(0) {|m, v| m + v} % 10
-    (remainder == 0 ? 0 : 10 - remainder).to_s
+    sum = (
+            base[1].to_i +
+            base[3].to_i +
+            base[5].to_i +
+            base[7].to_i +
+            base[9].to_i +
+            base[11].to_i
+          ) * 3 +
+          base[0].to_i +
+          base[2].to_i +
+          base[4].to_i +
+          base[6].to_i +
+          base[8].to_i +
+          base[10].to_i +
+          base[12].to_i
+
+    (10 - sum % 10).to_s[-1]
   end
 
   cache_method :isbn, :valid?, :isbn10, :isbn13, :parts, :isbn_10_checksum, :isbn_13_checksum
@@ -126,5 +154,9 @@ private
     isbn[-1..-1] == isbn_13_checksum
   end
 
-  RANGES = YAML::load_file(File.dirname(__FILE__) + "/../../data/ranges.yml")
+  RANGES = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('4.0.0')
+    YAML::load_file(File.dirname(__FILE__) + "/../../data/ranges.yml", permitted_classes: [Range, Symbol])
+  else
+    YAML::load_file(File.dirname(__FILE__) + "/../../data/ranges.yml")
+  end
 end

data/lisbn.gemspec

@@ -12,9 +12,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "lisbn"
   gem.require_paths = ["lib"]
-  gem.version       = "0.2.3"
+  gem.version       = "0.3.2"
 
   gem.add_dependency "nori", "~> 2.0"
   gem.add_dependency "nokogiri"
+  gem.add_development_dependency "multi_json"
+  gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
 end

data/spec/cache_method_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 class String
   extend Lisbn::CacheMethod
 
-  def with_excitement!
-    self + "!"
+  def with_excitement!(how_much = 1)
+    self + "!" * how_much
   end
 
   cache_method :with_excitement!
@@ -14,14 +14,27 @@ describe "cache_method" do
   subject { String.new("awesomeness") }
 
   it "evaluates the method the first time but not subsequent times" do
-    subject.should_receive(:+).with("!").once.and_return("you got stubbed!")
+    expect(subject).to receive(:+).with("!").once.and_call_original
     subject.with_excitement!
-    subject.with_excitement!.should == "you got stubbed!"
+    subject.with_excitement!
+  end
+
+  it "reevaluates the method if the arguments change" do
+    expect(subject).to receive(:+).with("!")
+    expect(subject).to receive(:+).with("!!")
+    subject.with_excitement!
+    subject.with_excitement!(2)
+  end
+
+  it "reevaluates the method if the block changes" do
+    expect(subject).to receive(:+).twice.and_call_original
+    subject.with_excitement! { "cats" }
+    subject.with_excitement! { "dogs" }
   end
 
   it "reevaluates the method if the object's hash changes" do
-    subject.with_excitement!.should == "awesomeness!"
+    expect(subject.with_excitement!).to eq("awesomeness!")
     subject.replace("more awesomeness")
-    subject.with_excitement!.should == "more awesomeness!"
+    expect(subject.with_excitement!).to eq("more awesomeness!")
   end
 end

data/spec/lisbn_spec.rb

@@ -4,54 +4,54 @@ describe "Lisbn" do
   describe "#isbn" do
     it "converts the string to just digits and X" do
       isbn = Lisbn.new("9487-028asdfasdf878X7")
-      isbn.isbn.should == "9487028878X7"
+      expect(isbn.isbn).to eq("9487028878X7")
     end
   end
 
   describe "#valid?" do
     it "recognizes a valid ISBN10" do
       isbn = Lisbn.new("0123456789")
-      isbn.valid?.should be true
+      expect(isbn.valid?).to be true
     end
 
     it "recognizes a valid ISBN10 with X checksum" do
       isbn = Lisbn.new("160459411X")
-      isbn.valid?.should be true
+      expect(isbn.valid?).to be true
     end
 
     it "recognizes a valid ISBN10 with 0 checksum" do
       isbn = Lisbn.new("0679405070")
-      isbn.valid?.should be true
+      expect(isbn.valid?).to be true
     end
 
     it "recognizes an invalid ISBN10" do
       isbn = Lisbn.new("0123546789")
-      isbn.valid?.should be false
+      expect(isbn.valid?).to be false
     end
 
     it "recognizes a valid ISBN13" do
       isbn = Lisbn.new("9780000000002")
-      isbn.valid?.should be true
+      expect(isbn.valid?).to be true
     end
 
     it "recognizes a valid ISBN13 with 0 checksum" do
       isbn = Lisbn.new("9780062870780")
-      isbn.valid?.should be true
+      expect(isbn.valid?).to be true
     end
 
     it "recognizes an invalid ISBN13" do
       isbn = Lisbn.new("9780000000003")
-      isbn.valid?.should be false
+      expect(isbn.valid?).to be false
     end
 
     it "returns false for improperly-formatted ISBNs" do
       isbn = Lisbn.new("97800000X0002")
-      isbn.valid?.should be false
+      expect(isbn.valid?).to be false
     end
 
     it "regards anything not 10 or 13 digits as invalid" do
       isbn = Lisbn.new("")
-      isbn.valid?.should be false
+      expect(isbn.valid?).to be false
     end
   end
 
@@ -69,8 +69,16 @@ describe "Lisbn" do
     context "with a 10-digit ISBN" do
       let(:isbn) { "1402780591" }
 
+      it "returns the isbn with dashes between the parts" do
+        expect(subject.isbn_with_dash).to eq("1-4027-8059-1")
+      end
+    end
+
+    context "with an invalid 9-digit ISBN" do
+      let(:isbn) { "402780591" }
+
       it "returns the isbn with a dash before the checkdigit" do
-        expect(subject.isbn_with_dash).to eq("140278059-1")
+        expect(subject.isbn_with_dash).to eq("40278059-1")
       end
     end
 
@@ -87,25 +95,25 @@ describe "Lisbn" do
     subject { Lisbn.new("9780000000002") }
 
     it "returns nil if invalid" do
-      subject.stub(:valid? => false)
-      subject.isbn10.should be_nil
+      allow(subject).to receive(:valid?) { false }
+      expect(subject.isbn10).to be_nil
     end
 
     it "returns nil if the ISBN is 13-digits and isn't in the 978 GS1" do
       lisbn = Lisbn.new("9790000000003")
-      lisbn.stub(:valid? => true)
-      lisbn.isbn10.should be_nil
+      allow(lisbn).to receive(:valid?) { true }
+      expect(lisbn.isbn10).to be_nil
     end
 
     it "computes the ISBN10 checksum" do
-      subject.isbn10.should == "0000000000"
+      expect(subject.isbn10).to eq("0000000000")
     end
 
     it "returns the isbn if it's 10 digits" do
       lisbn = Lisbn.new("0000000000")
-      lisbn.stub(:valid? => true)
-      lisbn.should_not_receive(:isbn_10_checksum)
-      lisbn.isbn10.should == "0000000000"
+      allow(lisbn).to receive(:valid?) { true }
+      expect(lisbn).not_to receive(:isbn_10_checksum)
+      expect(lisbn.isbn10).to eq("0000000000")
     end
   end
 
@@ -113,19 +121,19 @@ describe "Lisbn" do
     subject { Lisbn.new("0000000000") }
 
     it "returns nil if invalid" do
-      subject.stub(:valid? => false)
-      subject.isbn13.should be_nil
+      allow(subject).to receive(:valid?) { false }
+      expect(subject.isbn13).to be_nil
     end
 
     it "computes the ISBN13 checksum" do
-      subject.isbn13.should == "9780000000002"
+      expect(subject.isbn13).to eq("9780000000002")
     end
 
     it "returns the isbn if it's 13 digits" do
       lisbn = Lisbn.new("9780000000002")
-      lisbn.stub(:valid? => true)
-      lisbn.should_not_receive(:isbn_13_checksum)
-      lisbn.isbn13.should == "9780000000002"
+      allow(lisbn).to receive(:valid?) { true }
+      expect(lisbn).not_to receive(:isbn_13_checksum)
+      expect(lisbn.isbn13).to eq("9780000000002")
     end
   end
 
@@ -133,23 +141,74 @@ describe "Lisbn" do
     subject { Lisbn.new("9780000000002") }
 
     it "splits into the right groups" do
-      subject.parts.should == ["978", "0", "00", "000000", "2"]
+      expect(subject.parts).to eq(["978", "0", "00", "000000", "2"])
     end
 
     it "works with long groups" do
       lisbn = Lisbn.new("9786017002015")
-      lisbn.parts.should == ["978", "601", "7002", "01", "5"]
+      expect(lisbn.parts).to eq(["978", "601", "7002", "01", "5"])
+    end
+
+    it "should raise ArgumentError for anything other than 4 or 5" do
+      expect { subject.parts(3) }.to raise_error(ArgumentError)
+    end
+
+    it "splits into the right groups with number argument" do
+      expect(subject.parts(5)).to eq(["978", "0", "00", "000000", "2"])
     end
 
     it "returns nil if it can't find a valid group" do
       lisbn = Lisbn.new("9780100000002")
-      lisbn.parts.should be_nil
+      expect(lisbn.parts).to be_nil
+    end
+
+    it "uses the correct check digit if provided an isbn10" do
+      lisbn = Lisbn.new("0906212731")
+      expect(lisbn.parts).to eq(["978", "0", "906212", "73", "8"])
+    end
+
+    context "4 parts variant" do
+      it "splits isbn10 for parts with argument" do
+        lisbn = Lisbn.new("832100928X")
+        expect(lisbn.parts(4)).to eq(["83", "210", "0928", "X"])
+      end
+
+      it "works correctly for publisher identifier (CRC Press)" do
+        lisbn = Lisbn.new("0849304768")
+        expect(lisbn.parts(4)).to eq(["0", "8493", "0476", "8"])
+      end
+
+      it "works correctly with long publisher identifier (Tarquin Publications)" do
+        lisbn = Lisbn.new("0906212731")
+        expect(lisbn.parts(4)).to eq(["0", "906212", "73", "1"])
+      end
+
+      it "uses the correct check digit if provided an isbn13" do
+        lisbn = Lisbn.new("9780906212738")
+        expect(lisbn.parts(4)).to eq(["0", "906212", "73", "1"])
+      end
+
+      it "splits isbn10 for parts for initial isbn13" do
+        lisbn = Lisbn.new("9786017002015")
+        expect(lisbn.parts(4)).to eq(["601", "7002", "01", "5"])
+      end
+
+      it 'returns nil if ISBN-10 equivalent doesnt exists' do
+        lisbn = Lisbn.new("979-11-86178-14-0")
+        expect(lisbn.parts(4)).to be_nil
+      end
+
+      it "returns nil if it can't find a valid group" do
+        lisbn = Lisbn.new("9780100000002")
+        expect(lisbn.parts(4)).to be_nil
+      end
     end
   end
 
   describe "ranges" do
     it "skips over invalid '0-length' ranges" do
-      Lisbn::RANGES.values.flatten.map {|v| v[:length]}.should_not include(0)
+      range_lengths = Lisbn::RANGES.values.flatten.map {|v| v[:length]}
+      expect(range_lengths).not_to include(0)
     end
   end
 
@@ -157,7 +216,7 @@ describe "Lisbn" do
     subject { Lisbn.new("9780000000002") }
 
     it "#splits" do
-      subject.split("7").should == ["9", "80000000002"]
+      expect(subject.split("7")).to eq(["9", "80000000002"])
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 require 'lisbn'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lisbn
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.2
 platform: ruby
 authors:
 - Mike Ragalie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-17 00:00:00.000000000 Z
+date: 2022-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nori
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  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: 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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -60,6 +88,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/push.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - Gemfile
@@ -95,8 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Provides methods for converting between ISBN-10 and ISBN-13, checking validity