alexandria-book-collection-manager 0.7.1 → 0.7.6

data/spec/alexandria/book_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (C) 2007 Joseph Method
 # Copyright (C) 2011, 2015 Matijs van Zuijlen
 #
@@ -16,42 +18,44 @@
 # write to the Free Software Foundation, Inc., 51 Franklin Street,
 # Fifth Floor, Boston, MA 02110-1301 USA.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Alexandria::Book do
-  it 'should be a thing' do
+  it "is a thing" do
     an_artist_of_the_floating_world
   end
 
-  it 'should establish equality only with books with the same identity' do
+  it "establishes equality only with books with the same identity" do
     book = an_artist_of_the_floating_world
     same_book = an_artist_of_the_floating_world
     expect(same_book).to eq book
     different_book = an_artist_of_the_floating_world
-    different_book.isbn = '9780571147999'
+    different_book.isbn = "9780571147999"
     expect(different_book).not_to eq book
   end
 
-  describe '#rating' do
+  describe "#rating" do
     let(:book) { an_artist_of_the_floating_world }
-    it 'returns 0 by default' do
+
+    it "returns 0 by default" do
       expect(book.rating).to eq 0
     end
   end
 
-  describe '#rating=' do
+  describe "#rating=" do
     let(:book) { an_artist_of_the_floating_world }
-    it 'assigns rating' do
+
+    it "assigns rating" do
       book.rating = 5
       expect(book.rating).to eq 5
     end
 
-    it 'does not allow higher rating than 5 to be assigned' do
-      expect { book.rating = 6 }.to raise_error
+    it "does not allow higher rating than 5 to be assigned" do
+      expect { book.rating = 6 }.to raise_error ArgumentError
     end
 
-    it 'does not allow lower rating than 0 to be assigned' do
-      expect { book.rating = -1 }.to raise_error
+    it "does not allow lower rating than 0 to be assigned" do
+      expect { book.rating = -1 }.to raise_error ArgumentError
     end
   end
 end

data/spec/alexandria/console_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "spec_helper"
+
+RSpec.describe Alexandria do
+  let(:lib_version) { File.join(LIBDIR, "0.6.2") }
+
+  before do
+    FileUtils.cp_r(lib_version, TESTDIR)
+  end
+
+  describe ".list_books_on_console" do
+    it "returns a string containing a list of all books" do
+      expect(described_class.list_books_on_console).to eq <<~LIST
+        Pattern Recognition, William Gibson
+        Bonjour Tristesse, Francoise Sagan & Irene Ash
+        An Artist of the Floating World, Kazuo Ishiguro
+        The Dispossessed, Ursula Le Guin
+        Neverwhere, Neil Gaiman
+      LIST
+    end
+  end
+end

data/spec/alexandria/export_library_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
+#
+# See the file README.md for authorship and licensing information.
+
+require "spec_helper"
+
+RSpec.describe Alexandria::ExportLibrary do
+  let(:my_library) do
+    loader = Alexandria::LibraryStore.new(TESTDIR)
+    loader.load_library("My Library")
+  end
+  let(:format) { Alexandria::ExportFormat.all.find { |it| it.message == message } }
+  let(:outfile) do
+    outfile_base = format.ext ? "my-library.#{format.ext}" : "my-library"
+    File.join(Dir.tmpdir, outfile_base)
+  end
+  let(:unsorted) { Alexandria::LibrarySortOrder::Unsorted.new }
+
+  before do
+    test_library = File.join(LIBDIR, "0.6.2")
+    FileUtils.cp_r(test_library, TESTDIR)
+  end
+
+  after do
+    FileUtils.rm_rf(outfile) if File.exist? outfile
+  end
+
+  describe "#export_as_csv_list" do
+    let(:message) { :export_as_csv_list }
+
+    def load_rows_from_csv
+      CSV.read(outfile, col_sep: ";", headers: true)
+    end
+
+    it "can sort by title" do
+      sort_by_title = Alexandria::LibrarySortOrder.new(:title)
+      format.invoke(my_library, sort_by_title, outfile)
+      rows = load_rows_from_csv
+      titles = rows.map { |it| it["Title"] }
+      expect(titles).to eq titles.sort
+    end
+
+    it "can sort in descending order" do
+      sort_by_date_desc = Alexandria::LibrarySortOrder.new(:publishing_year, false)
+      format.invoke(my_library, sort_by_date_desc, outfile)
+      rows = load_rows_from_csv
+      dates = rows.map { |it| it["Year Published"] }
+      expect(dates).to eq dates.sort.reverse
+    end
+  end
+
+  describe "#export_as_html" do
+    let(:message) { :export_as_html }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile, Alexandria::WebTheme.all.first)
+      index = File.join(outfile, "index.html")
+
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.exist?(index)).to be_truthy
+        expect(File.size(index)).to be_nonzero
+      end
+    end
+  end
+
+  describe "#export_as_onix_xml_archive" do
+    let(:message) { :export_as_onix_xml_archive }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.size(outfile)).to be_nonzero
+      end
+    end
+  end
+
+  describe "#export_as_tellico_xml_archive" do
+    let(:message) { :export_as_tellico_xml_archive }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.size(outfile)).to be_nonzero
+      end
+    end
+  end
+
+  describe "#export_as_bibtex" do
+    let(:message) { :export_as_bibtex }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.size(outfile)).to be_nonzero
+      end
+    end
+  end
+
+  describe "#export_as_isbn_list" do
+    let(:message) { :export_as_isbn_list }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile)
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.size(outfile)).to be_nonzero
+      end
+    end
+  end
+
+  describe "#export_as_ipod_notes" do
+    let(:message) { :export_as_ipod_notes }
+
+    it "can export unsorted" do
+      format.invoke(my_library, unsorted, outfile, nil)
+      index = File.join(outfile, "index.linx")
+
+      aggregate_failures do
+        expect(File.exist?(outfile)).to be_truthy
+        expect(File.size(index)).to be_nonzero
+      end
+    end
+  end
+end

data/spec/alexandria/library_spec.rb

@@ -1,105 +1,92 @@
-#-- -*- ruby -*-
-# Copyright (C) 2004-2006 Dafydd Harries
-# Copyright (C) 2007 Cathal Mc Ginley
-# Copyright (C) 2011, 2014-2016 Matijs van Zuijlen
-#
-# Alexandria is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version.
-#
-# Alexandria is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
+# frozen_string_literal: true
+
+# This file is part of Alexandria.
 #
-# You should have received a copy of the GNU General Public
-# License along with Alexandria; see the file COPYING.  If not,
-# write to the Free Software Foundation, Inc., 51 Franklin Street,
-# Fifth Floor, Boston, MA 02110-1301 USA.
+# See the file README.md for authorship and licensing information.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Alexandria::Library do
-  describe '::EXT' do
-    it 'has symbolic references to file extensions' do
+  let(:loader) { Alexandria::LibraryStore.new(TESTDIR) }
+
+  describe "::EXT" do
+    it "has symbolic references to file extensions" do
       extensions = Alexandria::Library::EXT
       expect(extensions[:book]).not_to be_nil
       expect(extensions[:cover]).not_to be_nil
     end
   end
 
-  describe '#valid_isbn?' do
-    it 'returns a true value for valid isbns' do
-      for x in ['014143984X', '0-345-43192-8']
-        expect(Alexandria::Library.valid_isbn?(x)).to be_truthy
+  describe "#valid_isbn?" do
+    it "returns a true value for valid isbns" do
+      ["014143984X", "0-345-43192-8"].each do |x|
+        expect(described_class.valid_isbn?(x)).to be_truthy
       end
     end
   end
 
-  describe '#valid_ean?' do
-    it 'returns a true value for valid EANs' do
-      expect(Alexandria::Library.valid_ean?('9780345431929')).to be_truthy
-      expect(Alexandria::Library.valid_ean?('978034543192912345')).to be_truthy
+  describe "#valid_ean?" do
+    it "returns a true value for valid EANs" do
+      expect(described_class.valid_ean?("9780345431929")).to be_truthy
+      expect(described_class.valid_ean?("978034543192912345")).to be_truthy
 
       # Regression test: this EAN has a checksum of 10, which should be
       # treated like a checksum of 0.
-      expect(Alexandria::Library.valid_ean?('9784047041790')).to be_truthy
+      expect(described_class.valid_ean?("9784047041790")).to be_truthy
     end
 
-    it 'returns a false value for invalid EANs' do
-      expect(Alexandria::Library.valid_ean?('780345431929')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('97803454319290')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('97803454319291234')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431929123456')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431928')).to be_falsey
-      expect(Alexandria::Library.valid_ean?('9780345431929A')).to be_falsey
+    it "returns a false value for invalid EANs" do
+      expect(described_class.valid_ean?("780345431929")).to be_falsey
+      expect(described_class.valid_ean?("97803454319290")).to be_falsey
+      expect(described_class.valid_ean?("97803454319291234")).to be_falsey
+      expect(described_class.valid_ean?("9780345431929123456")).to be_falsey
+      expect(described_class.valid_ean?("9780345431928")).to be_falsey
+      expect(described_class.valid_ean?("9780345431929A")).to be_falsey
 
-      expect(Alexandria::Library.valid_ean?('9784047041791')).to be_falsey
+      expect(described_class.valid_ean?("9784047041791")).to be_falsey
     end
   end
 
-  describe '#valid_upc?' do
-    it 'returns a true value for valid UPCs' do
-      expect(Alexandria::Library.valid_upc?('97803454319312356')).to be_truthy
+  describe "#valid_upc?" do
+    it "returns a true value for valid UPCs" do
+      expect(described_class.valid_upc?("97803454319312356")).to be_truthy
     end
 
-    it 'returns a false value for invalid UPCs' do
-      expect(Alexandria::Library.valid_upc?('978034543193123567')).to be_falsey
-      expect(Alexandria::Library.valid_upc?('9780345431931235')).to be_falsey
+    it "returns a false value for invalid UPCs" do
+      expect(described_class.valid_upc?("978034543193123567")).to be_falsey
+      expect(described_class.valid_upc?("9780345431931235")).to be_falsey
 
-      expect(Alexandria::Library.valid_upc?('97803454319412356')).to be_falsey
-      expect(Alexandria::Library.valid_upc?('97803454319212356')).to be_falsey
+      expect(described_class.valid_upc?("97803454319412356")).to be_falsey
+      expect(described_class.valid_upc?("97803454319212356")).to be_falsey
     end
   end
 
-  describe '#canonicalise_isbn' do
-    it 'returns the correct value for several examples' do
-      expect(Alexandria::Library.canonicalise_isbn('014143984X')).to eq '014143984X'
-      expect(Alexandria::Library.canonicalise_isbn('0-345-43192-8')).to eq '0345431928'
-      expect(Alexandria::Library.canonicalise_isbn('3522105907')).to eq '3522105907'
+  describe "#canonicalise_isbn" do
+    it "returns the correct value for several examples" do
+      expect(described_class.canonicalise_isbn("014143984X")).to eq "014143984X"
+      expect(described_class.canonicalise_isbn("0-345-43192-8")).to eq "0345431928"
+      expect(described_class.canonicalise_isbn("3522105907")).to eq "3522105907"
       # EAN number
-      expect(Alexandria::Library.canonicalise_isbn('9780345431929')).to eq '0345431928'
+      expect(described_class.canonicalise_isbn("9780345431929")).to eq "0345431928"
     end
   end
 
-  context 'with an empty library' do
-    before(:each) do
+  context "with an empty library" do
+    let(:my_library) { loader.load_library("Empty") }
+
+    before do
       FileUtils.mkdir(TESTDIR) unless File.exist? TESTDIR
     end
 
-    it 'disallows multiple deletion of the same copy of a book' do
-      my_library = Alexandria::Library.loadall[0]
+    it "disallows multiple deletion of the same copy of a book" do
       first_copy = an_artist_of_the_floating_world
       my_library << first_copy
       my_library.delete(first_copy)
       expect { my_library.delete(first_copy) }.to raise_error ArgumentError
     end
 
-    it 'allows multiple copies of a book to be added and deleted in turn' do
-      my_library = Alexandria::Library.loadall[0]
+    it "allows multiple copies of a book to be added and deleted in turn" do
       first_copy = an_artist_of_the_floating_world
-      # puts "first_copy #{first_copy.object_id}"
       my_library << first_copy
       my_library.delete(first_copy)
 
@@ -108,169 +95,140 @@ describe Alexandria::Library do
       third_copy = an_artist_of_the_floating_world
       my_library << third_copy
 
-      # puts "AAA my_library.size #{my_library.size}"
-
-      # puts "second_copy #{second_copy.object_id}"
       expect { my_library.delete(second_copy) }.not_to raise_error
-
-      # puts "BBB my_library.size #{my_library.size}"
-      # my_library.size.should == 1 # not yet an established feature...
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
     end
   end
 
-  describe '.import_as_isbn_list' do
-    before :all do
-      require 'alexandria/import_library'
-    end
-
-    def __test_fake_import_isbns
-      libraries = Alexandria::Libraries.instance
-      library = Alexandria::Library.new('Test Library')
+  describe ".import_as_isbn_list" do
+    before do
+      libraries = Alexandria::LibraryCollection.instance
+      library = described_class.new("Test Library")
       libraries.add_library(library)
-      [library, libraries]
+
+      allow(Alexandria::BookProviders)
+        .to receive(:isbn_search)
+        .and_raise Alexandria::BookProviders::SearchEmptyError
+      allow(Alexandria::BookProviders)
+        .to receive(:isbn_search).with("0595371086")
+        .and_return(an_artist_of_the_floating_world)
     end
 
-    it "doesn't work quite yet" do
-      skip
-      # Doesn't work quite yet.
-      on_iterate_cb = proc {}
-      on_error_cb = proc {}
-      library, _libraries = __test_fake_import_isbns
-      test_file = 'data/isbns.txt'
-      library.import_as_isbn_list('Test Library', test_file, on_iterate_cb, on_error_cb)
+    it "imports books with correct isbn and search result" do
+      library, bad_isbns, failed_lookup_isbns =
+        described_class.import_as_isbn_list("Test Library", "spec/data/isbns.txt",
+                                            proc {}, proc {})
+
+      aggregate_failures do
+        expect(library.to_a).to eq [an_artist_of_the_floating_world]
+        expect(bad_isbns).to eq ["0911826449"]
+        expect(failed_lookup_isbns).to eq ["0740704923"]
+      end
     end
   end
 
-  context 'imported from 0.6.1 data files' do
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.1')
+  context "when importing from 0.6.1 data files" do
+    let(:libs) { loader.load_all_libraries }
+    let(:my_library) { libs[0] }
+
+    before do
+      lib_version = File.join(LIBDIR, "0.6.1")
       FileUtils.cp_r(lib_version, TESTDIR)
     end
 
-    it 'imports cleanly from version 0.6.1 data format' do
-      libs = Alexandria::Library.loadall
+    it "can be loaded" do
       expect(libs.size).to eq(1)
-      my_library = libs[0]
       expect(my_library.size).to eq(3)
+    end
+
+    it "imports cleanly from version 0.6.1 data format" do
       # Malory
-      malory_book = my_library.select { |b| b.isbn == '9780192812179' }[0]
-      expect(malory_book.publisher).to eq('Oxford University Press')
-      expect(malory_book.authors.include?('Vinaver')).to be_truthy
+      malory_book = my_library.find { |b| b.isbn == "9780192812179" }
+      expect(malory_book.publisher).to eq("Oxford University Press")
+      expect(malory_book.authors.include?("Vinaver")).to be_truthy
       expect(malory_book.version).to eq(Alexandria::DATA_VERSION)
 
       # Guide to LaTeX
-      latex_book = my_library.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book.isbn).to eq('9780201398250')
-      expect(latex_book.publisher).to eq('Addison Wesley') # note, no Ruby-Amazon cruft
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
+      latex_book = my_library.find { |b| b.title.include? "Latex" }
+      expect(latex_book.isbn).to eq("9780201398250")
+      expect(latex_book.publisher).to eq("Addison Wesley") # note, no Ruby-Amazon cruft
     end
   end
 
-  context 'imported from 0.6.1 with books without an ISBN' do
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.1-noisbn')
+  context "when importing from 0.6.1 with books without an ISBN" do
+    let(:libs) { loader.load_all_libraries }
+    let(:my_library) { libs[0] }
+
+    before do
+      lib_version = File.join(LIBDIR, "0.6.1-noisbn")
       FileUtils.cp_r(lib_version, TESTDIR)
     end
 
-    it 'allows books to have no ISBN' do
-      libs = Alexandria::Library.loadall
+    after do
+      FileUtils.rm_rf(TESTDIR)
+    end
+
+    it "can be loaded" do
       expect(libs.size).to eq(1)
-      my_library = libs[0]
       expect(my_library.size).to eq(2)
+    end
 
+    it "loads a book with ISBN" do
       # Guide to LaTeX
-      latex_book = my_library.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book.isbn).to eq('9780201398250')
-      expect(latex_book.publisher).to eq('Addison Wesley') # note, no Ruby-Amazon cruft
+      latex_book = my_library.find { |b| b.title.include? "Latex" }
+      expect(latex_book.isbn).to eq("9780201398250")
+      expect(latex_book.publisher).to eq("Addison Wesley") # note, no Ruby-Amazon cruft
       expect(latex_book.version).to eq(Alexandria::DATA_VERSION)
+    end
 
+    it "loads a book without ISBN" do
       # Lex and Yacc
-      lex_and_yacc_book = my_library.select { |b| b.title.include? 'Lex' }[0]
+      lex_and_yacc_book = my_library.find { |b| b.title.include? "Lex" }
       expect(lex_and_yacc_book.publisher).to eq("O'Reilley")
+    end
 
-      # puts "ident -> " + lex_and_yacc_book.ident
-
-      my_library.each do |book|
-        my_library.save(book, true)
-      end
-
-      libraries_reloaded = Alexandria::Library.loadall
-      my_library_reloaded = libraries_reloaded[0]
-
+    it "saves loaded books properly" do
+      my_library.each { |book| my_library.save(book, true) }
+      my_library_reloaded = loader.load_all_libraries[0]
       expect(my_library_reloaded.size).to eq(2)
 
-      latex_book = my_library_reloaded.select { |b| b.title.include? 'Latex' }[0]
-      expect(latex_book).not_to be_nil
-      expect(latex_book.publisher).to eq('Addison Wesley')
-      # puts latex_book.title
+      latex_book = my_library_reloaded.find { |b| b.title.include? "Latex" }
+      expect(latex_book.publisher).to eq("Addison Wesley")
 
-      lex_and_yacc_book = my_library_reloaded.select { |b| b.title.include? 'Lex' }[0]
-      expect(lex_and_yacc_book).not_to be_nil
+      lex_and_yacc_book = my_library_reloaded.find { |b| b.title.include? "Lex" }
       expect(lex_and_yacc_book.publisher).to eq("O'Reilley")
-      # puts lex_and_yacc_book.title
-    end
-
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
     end
   end
 
-  context 'when exporting' do
-    before(:all) do
-      require 'tmpdir'
-      require 'csv'
-    end
+  describe ".move" do
+    let(:source) { loader.load_library("My Library") }
+    let(:target) { loader.load_library("Target") }
+    let(:book) { source.first }
 
-    before(:each) do
-      lib_version = File.join(LIBDIR, '0.6.2')
+    before do
+      lib_version = File.join(LIBDIR, "0.6.2")
       FileUtils.cp_r(lib_version, TESTDIR)
-      @format = Alexandria::ExportFormat.new('CSV list', 'csv', :export_as_csv_list)
-      @outfile = File.join(Dir.tmpdir, 'my_library-0.6.2.csv')
-      @my_library = Alexandria::Library.loadall[0]
     end
 
-    def load_rows_from_csv
-      CSV.read(@outfile, col_sep: ';')
-    end
+    it "changes the number of books in the source and target libraries" do
+      count = source.count
 
-    it 'can sort by title' do
-      sort_by_title = Alexandria::LibrarySortOrder.new(:title)
-      @format.invoke(@my_library, sort_by_title, @outfile)
-      expect(File.exist?(@outfile)).to be_truthy
-      rows = load_rows_from_csv
-      rows.shift
-      expect(rows.size).to eq(@my_library.size)
-      TITLE = 0
-      comparisons = rows.size - 1
-      comparisons.times do |index|
-        expect(rows[index][TITLE]).to be <= rows[index + 1][TITLE]
-      end
-    end
+      described_class.move(source, target, book)
 
-    it 'can sort in descending order' do
-      sort_by_date_desc = Alexandria::LibrarySortOrder.new(:publishing_year, false)
-      @format.invoke(@my_library, sort_by_date_desc, @outfile)
-      expect(File.exist?(@outfile)).to be_truthy
-      rows = load_rows_from_csv
-      rows.shift
-      expect(rows.size).to eq(@my_library.size)
-      DATE = 5
-      comparisons = rows.size - 1
-      comparisons.times do |index|
-        expect(rows[index][DATE]).to be >= rows[index + 1][DATE]
+      aggregate_failures do
+        expect(source.count).to eq count - 1
+        expect(target.count).to eq 1
       end
     end
 
-    after(:each) do
-      FileUtils.rm_rf(TESTDIR)
-      File.unlink @outfile if File.exist? @outfile
+    it "moves the book files from source to target" do
+      described_class.move(source, target, book)
+
+      aggregate_failures do
+        expect(File.exist?(source.yaml(book))).to be_falsey
+        expect(File.exist?(source.cover(book))).to be_falsey
+        expect(File.exist?(target.yaml(book))).to be_truthy
+        expect(File.exist?(target.cover(book))).to be_truthy
+      end
     end
   end
 end