audio_book_creator 0.0.1

data/spec/audio_book_creator/editor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe AudioBookCreator::Editor do
+  let(:page_def) { AudioBookCreator::PageDef.new("h1", "p") }
+  subject { described_class.new(page_def) }
+  let(:chapter1) { chapter("first\n\nsecond", "the title") }
+  it "should generate a page" do
+    expect(subject.parse([page("page1", "<h1>the title</h1>",
+                               "<p>first</p>", "<p>second</p>")
+                         ])).to eq([chapter1])
+  end
+
+  it "should respect content path" do
+    page_def.title_path = "h3"
+    page_def.body_path = "#story p"
+    expect(subject.parse([page("page1", "<h3>the title</h3>",
+                                "<div id='story'>", "<p>first</p>", "<p>second</p>", "</div>",
+                                "<p>bad</p>")
+                          ])).to eq([chapter1])
+  end
+
+  it "should ignore body formatting" do
+    expect(subject.parse([page("page1", "<h1>the title</h1>",
+                               "<p><a href='#this'>first</a></p>", "<p><b>second</b></p>")
+                         ])).to eq([chapter1])
+  end
+
+  it "should parse multiple pages" do
+    expect(subject.parse([page("page1", "<h1>p1</h1>", "<p>first</p>"),
+                          page("page2", "<h1>p2</h1>", "<p>second</p>"),
+                         ])).to eq([chapter("first", "p1", 1), chapter("second", "p2", 2)])
+  end
+
+  it "should default the title if none found" do
+    expect(subject.parse([page("page1", "<p>first</p>"),
+                          page("page2", "<p>second</p>"),
+                         ])).to eq([chapter("first", "Chapter 1", 1), chapter("second", "Chapter 2", 2)])
+  end
+end

data/spec/audio_book_creator/logging_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe AudioBookCreator::Logging do
+  subject { Class.new.tap { |c| c.send(:include, described_class) }.new}
+  it "should not log strings when verbose is off" do
+    subject.logger.info "phrase"
+    expect_to_have_logged()
+  end
+
+  it "should log strings" do
+    enable_logging
+    subject.logger.info "phrase"
+    expect_to_have_logged("phrase")
+  end
+
+  it "should log blocks" do
+    enable_logging
+    subject.logger.info { "phrase" }
+    expect_to_have_logged("phrase")
+  end
+end

data/spec/audio_book_creator/page_db_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+require 'tempfile'
+
+describe AudioBookCreator::PageDb do
+  subject { described_class.new(":memory:") }
+
+  # all of these tests are in memory
+  # this is the only test that depends upon it
+  context "with memory databases" do
+    it "does not create a file" do
+      # access key to trigger database creation
+      subject["key"]
+      expect(File).not_to be_exist(":memory:")
+    end
+  end
+
+  it "works" do
+    expect(subject).not_to be_nil
+  end
+
+  it "creates cache value" do
+    subject["key"] = "value"
+
+    expect(subject["key"]).to eq("value")
+  end
+
+  it "include good key" do
+    subject["key"] = "value"
+    expect(subject).to include("key")
+  end
+
+  it "doesnt include bad key" do
+    expect(subject).not_to include("key")
+  end
+
+  context "with prepopulated (file) database" do
+    let(:tmp) { Tempfile.new("db") }
+
+    before do
+      db = described_class.new(tmp.path)
+      db["key"] = "value"
+    end
+
+    after do
+      tmp.close
+      tmp.unlink
+    end
+
+    it "finds entry in previously created cache" do
+      db = described_class.new(tmp.path)
+      expect(db["key"]).to eq("value")
+    end
+
+    it "creates a file" do
+      expect(File.exist?(tmp.path)).to be_truthy
+    end
+  end
+
+  it "handles url keys" do
+    key = "http://the.web.site.com/path/to/cgi?param1=x&param2=y#substuff"
+    contents = "a" * 555
+    subject[key] = contents
+    expect(subject[key]).to eq(contents)
+  end
+
+  it "supports enumerable (map)" do
+    subject["keyc"] = "v"
+    subject["keya"] = "v"
+    subject["keyz"] = "v"
+
+    expect(subject.map { |(n, v)| "#{n}:#{v}" }).to eq(%w(keyc:v keya:v keyz:v))
+  end
+
+end

data/spec/audio_book_creator/page_def_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe AudioBookCreator::PageDef do
+  context "with no parameter" do
+    subject { described_class.new() }
+    it { expect(subject.title_path).to eq("h1") }
+    it { expect(subject.body_path).to eq("p") }
+    it { expect(subject.link_path).to eq("a") }
+    it { expect(subject.chapter_path).to be_nil }
+  end
+
+  context "with all parameters" do
+    subject { described_class.new("h1.title", "div", "a.link", "a.chapter") }
+    it { expect(subject.title_path).to eq("h1.title") }
+    it { expect(subject.body_path).to eq("div") }
+    it { expect(subject.link_path).to eq("a.link") }
+    it { expect(subject.chapter_path).to eq("a.chapter") }
+  end
+
+  describe "#title" do
+    context "with no title" do
+      let(:page) { dom("<p></p>")}
+      it { expect(subject.title(page)).to be_nil}
+    end
+    context "with title" do
+      let(:page) { dom("<h1>title</h1>")}
+      it { expect(subject.title(page)).to eq("title")}
+    end
+  end
+
+  # NOTE: chapter uses array.join
+  describe "#body" do
+    context "with no body" do
+      let(:page) { dom("<h1></h1>")}
+      it { expect(subject.body(page)).to be_empty}
+    end
+    context "with body" do
+      let(:page) { dom("<p>p1</p>")}
+      it { expect(Array(subject.body(page)).join).to eq("p1") }
+    end
+    context "with many bodies" do
+      let(:page) { dom("<p>p1</p><p>p2</p><p>p3</p><p>p4</p>")}
+      it { expect(Array(subject.body(page)).join).to eq(%w(p1 p2 p3 p4).join) }
+    end
+  end
+
+  describe "#page_links" do
+    context "with no page_links" do
+      let(:page) { dom("<p></p>")}
+      it { expect(subject.page_links(page){ |r| r["href"] }).to be_empty}
+    end
+    context "with multiple page_links" do
+      let(:page) { dom("<a href='tgt1'>a</a><a href='tgt2'>a</a>")}
+      it { expect(subject.page_links(page){ |r| r["href"] }).to eq(%w(tgt1 tgt2))}
+    end
+  end
+
+  describe "#chapter_links" do
+    before { subject.chapter_path = "a.chapter"}
+    context "with no chapter_links" do
+      let(:page) { dom("<p></p>")}
+      it { expect(subject.chapter_links(page){ |r| r["href"] }).to be_empty }
+    end
+    context "with only page_links" do
+      let(:page) { dom("<p><a href='x'>x</a></p>")}
+      it { expect(subject.chapter_links(page){ |r| r["href"] }).to be_empty }
+    end
+    context "with multiple chapter_links" do
+      let(:page) { dom("<a class='chapter' href='tgt1'>a</a><a class='chapter' href='tgt2'>a</a>") }
+      it { expect(subject.chapter_links(page){ |r| r["href"] }).to eq(%w(tgt1 tgt2)) }
+    end
+    context "with nil chapter_path" do
+      before { subject.chapter_path = nil }
+      let(:page) { dom("<a class='chapter' href='tgt1'>a</a><a class='chapter' href='tgt2'>a</a>") }
+      it { expect(subject.chapter_links(page) { |r| r["href"] }).to be_empty }
+    end
+  end
+end
+

data/spec/audio_book_creator/runner_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe AudioBookCreator::Runner do
+  subject { described_class.new }
+
+  context "with successful command" do
+    it "runs commands with arguments" do
+      expect(subject).to receive(:system).with("cmd", "arg1", "arg2").and_return(true)
+      subject.run!("cmd", :params => %w(arg1 arg2))
+    end
+
+    it "runs commands with non string arguments" do
+      expect(subject).to receive(:system).with("cmd", "arg1", "1").and_return(true)
+      subject.run!("cmd", :params => ["arg1", 1])
+    end
+
+    it "runs commands with hashes and nested arrays" do
+      expect(subject).to receive(:system).with("cmd", "arg1", "a", "b").and_return(true)
+      subject.run!("cmd", :params => {arg1: %w(a b)})
+    end
+
+    it "runs commands with nils" do
+      expect(subject).to receive(:system).with("cmd", "arg1").and_return(true)
+      subject.run!("cmd", :params => {arg1: nil})
+    end
+
+    context "without verbose" do
+      it "doesnt log" do
+        expect(subject).to receive(:system).and_return(true)
+        subject.run!("cmd", :params => %w(arg1 arg2))
+        expect_to_have_logged()
+      end
+    end
+
+    context "with verbose" do
+      before { enable_logging }
+      it "logs messages" do
+        expect(subject).to receive(:system).and_return(true)
+        expect(subject.run!("cmd", :params => %w(arg1 arg2))).to be_truthy
+        expect_to_have_logged(/run: cmd arg1 arg2/, "", "", "success")
+      end      
+    end
+  end
+
+  context "with failing command" do
+    it "returns false" do
+      expect(subject).to receive(:system).and_return(false)
+      expect(subject.run("cmd", :params => %w(arg1 arg2))).not_to be_truthy
+    end
+
+    it "raises exception" do
+      expect(subject).to receive(:system).and_return(false)
+      expect { subject.run!("cmd", :params => %w(arg1 arg2)) }.to raise_error(/trouble/)
+    end
+
+    context "with verbose" do
+      before { enable_logging }
+      it "logs messages" do
+        expect(subject).to receive(:system).and_return(false)
+        expect { subject.run!("cmd", :params => %w(arg1 arg2)) }.to raise_error(/trouble/)
+        expect_to_have_logged(/run.*cmd.*arg1 arg2/, "", "", "issue")
+      end
+    end
+  end
+end

data/spec/audio_book_creator/speaker_def_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe AudioBookCreator::SpeakerDef do
+  context "with no parameters" do
+    subject { described_class.new }
+    # for speaking the chapter
+    it { expect(subject.voice).to eq("Vicki") }
+    it { expect(subject.rate).to eq(280) }
+    # for binding the book
+    it { expect(subject.channels).to eq(1) }
+    it { expect(subject.bit_rate).to eq(32) }
+    it { expect(subject.max_hours).to eq(7) }
+    it { expect(subject.sample_rate).to eq(22_050) }
+    it { expect(subject.regen_audio).to be_falsy }
+  end
+
+  context "with parameters" do
+    subject do
+        described_class.new(
+            voice: "Serena",
+            rate: 360,
+            channels: 2,
+            bit_rate: 64,
+            max_hours: 2,
+            sample_rate: 44100,
+            regen_audio: true,
+        )
+    end
+
+    it { expect(subject.voice).to eq("Serena") }
+    it { expect(subject.rate).to eq(360) }
+    # for binding the book
+    it { expect(subject.channels).to eq(2) }
+    it { expect(subject.bit_rate).to eq(64) }
+    it { expect(subject.max_hours).to eq(2) }
+    it { expect(subject.sample_rate).to eq(44_100) }
+    it { expect(subject.regen_audio).to be_truthy }
+  end
+end

data/spec/audio_book_creator/speaker_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe AudioBookCreator::Speaker do
+  let(:book_def) { AudioBookCreator::BookDef.new("dir") }
+  let(:speaker_def) { AudioBookCreator::SpeakerDef.new(:regen_audio => false) }
+  subject { described_class.new(speaker_def, book_def) }
+  it "should require a non empty chapter" do
+    expect_runner.not_to receive(:system)
+    expect { subject.say(chapter(nil)) }.to raise_error
+  end
+
+  it "should do nothing if txt and mp4 file exist" do
+    expect(File).to receive(:exist?).with("dir/chapter01.txt").and_return(true)
+    expect(File).to receive(:exist?).with("dir/chapter01.m4a").and_return(true)
+
+    expect(File).not_to receive(:write)
+    expect_runner.not_to receive(:system)
+    expect(subject.say(chapter)).to eq(spoken_chapter("the title", "dir/chapter01.m4a"))
+  end
+
+  it "should create text and mp4 file" do
+    expect(File).to receive(:exist?).twice.and_return(false)
+    expect(File).to receive(:write).with("dir/chapter01.txt", "the title\n\ncontent\n")
+
+    expect_runner.to receive(:system)
+      .with("say", "-v", "Vicki", "-r", "280", "-f", "dir/chapter01.txt", "-o", "dir/chapter01.m4a").and_return(true)
+    subject.say(chapter)
+  end
+
+  it "doesnt print if not verbose" do
+    expect(File).to receive(:exist?).twice.and_return(false)
+    expect(File).to receive(:write)
+
+    expect_runner.to receive(:system).and_return(true)
+    subject.say(chapter)
+    expect_to_have_logged()
+  end
+
+  it "should output messages if set to verbose" do
+    enable_logging
+    expect(File).to receive(:exist?).twice.and_return(false)
+    expect(File).to receive(:write)
+
+    expect_runner.to receive(:system).and_return(true)
+    subject.say(chapter)
+    expect_to_have_logged(/^run:/, "", "", "success")
+  end
+
+  context "with force" do
+    before { speaker_def.regen_audio = true}
+    subject { described_class.new(speaker_def, book_def) }
+
+    it "should create text and mp4 file if they exist but are set to force" do
+      expect(File).not_to receive(:exist?)
+      expect(File).to receive(:write)
+
+      expect_runner.to receive(:system).and_return(true)
+      subject.say(chapter)
+    end
+  end
+
+  it "should freak if no chapters are passed in" do
+    expect_runner.not_to receive(:system)
+    expect { subject.say([]) }.to raise_error("Empty chapter")
+  end
+
+  context "#make_directory_structure" do
+    it "should create base directory" do
+      expect_runner.not_to receive(:system)
+      expect(File).to receive(:exist?).with(subject.book_def.base_dir).and_return(false)
+      expect(FileUtils).to receive(:mkdir).with(subject.book_def.base_dir)
+      subject.make_directory_structure
+    end
+
+    it "should not create base directory if it exists" do
+      expect_runner.not_to receive(:system)
+      expect(File).to receive(:exist?).with(subject.book_def.base_dir).and_return(true)
+      expect(FileUtils).not_to receive(:mkdir)
+      subject.make_directory_structure
+    end
+  end
+
+  context "#chapter_text_filename" do
+    let(:chapter) { AudioBookCreator::Chapter.new(number: 3) }
+
+    it do
+      expect_runner.not_to receive(:system)
+      expect(subject.chapter_text_filename(chapter)).to eq("dir/chapter03.txt")
+    end
+  end
+
+  context "#chapter_sound_filename" do
+    let(:chapter) { AudioBookCreator::Chapter.new(number: 2) }
+    it do
+      expect_runner.not_to receive(:system)
+      expect(subject.chapter_sound_filename(chapter)).to eq("dir/chapter02.m4a")
+    end
+  end
+
+  private
+
+  def expect_runner
+    expect_any_instance_of(AudioBookCreator::Runner)
+  end
+end

data/spec/audio_book_creator/spider_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+
+describe AudioBookCreator::Spider do
+  # set a max to prevent errors from causing infinite loops
+  let(:page_def) { AudioBookCreator::PageDef.new("h1", "p", "a.page", "a.chapter") }
+  let(:web) { {} }
+  let(:invalid_urls) { {} }
+  # NOTE: could use arrays here, but put caps to catch bugs
+  subject { described_class.new(page_def, web, invalid_urls) }
+
+  it "handles empty initializer" do
+    pristine = described_class.new(page_def)
+    expect(pristine.web).to be_a(Hash)
+    expect(pristine.invalid_urls).to be_a(Hash)
+  end
+
+  it "sets arguments" do
+    expect(subject.page_def).to eq(page_def)
+    expect(subject.web).to eq(web)
+    expect(subject.invalid_urls).not_to be_nil
+  end
+
+  context "#visit" do
+    it "visit urls" do
+      expect_visit_page "page1", "x"
+      expect(subject.run(uri(%w(page1)))).to eq([page(site("page1"),"x")])
+    end
+
+    it "visit string" do
+      expect_visit_page "page1", "x"
+      expect(subject.run(site(%w(page1)))).to eq([page(site("page1"),"x")])
+    end
+
+    it "visit multiple pages" do
+      expect_visit_page "page1"
+      expect_visit_page "page2"
+      expect(subject.run(uri(%w(page1 page2))))
+        .to eq([page(site("page1")), page(site("page2"))])
+    end
+
+    it "visit unique list of pages" do
+      expect_visit_page "page1", link("page2"), link("page2")
+      expect_visit_page "page2"
+      expect(subject.run uri(%w(page1)))
+        .to eq([page(site("page1"),link("page2"), link("page2")), page(site("page2"))])
+    end
+
+    it "skips loops from uri" do
+      expect_visit_page "page1", link("page1")
+      subject.run uri(%w(page1))
+    end
+
+    it "skips loops from string" do
+      expect_visit_page "page1", link("page1")
+      subject.run site(%w(page1))
+    end
+
+    it "also accepts string urls" do
+      expect_visit_page "page1"
+      subject.run site(%w(page1))
+    end
+
+    it "skips empty urls" do
+      expect_visit_page "page1", "<a>x</a>"
+      subject.run site(%w(page1))
+    end
+
+    it "skips blank urls" do
+      expect_visit_page "page1", "<a href=\"\">x</a>"
+      subject.run site(%w(page1))
+    end
+  end
+
+  it "follows relative links" do
+    expect_visit_page("page1", link("page2"))
+    expect_visit_page("page2")
+    subject.run uri(%w(page1))
+  end
+
+  it "follows absolute links" do
+    expect_visit_page("page1", link(site("page2")))
+    expect_visit_page("page2")
+    subject.run uri(%w(page1))
+  end
+
+  # in the end of the day, these links reference the local page which is ignored, so no code necessary
+  it "skips empty, blank, and local ref links" do
+    p1_contents = "<a id='a1'>a1</a>", "<a href=''>a2</a>", "<a href='#a'>x</a>", link("page2")
+    expect_visit_page("page1", *p1_contents)
+    expect_visit_page("page2")
+    expect(subject.run uri(%w(page1))).to eq([page(site("page1"), *p1_contents), page(site("page2"))])
+  end
+
+  it "visits all pages once (and only once)" do
+    expect_visit_page("page1", link("page2"))
+    expect_visit_page("page2", link("page1"), link("page3"))
+    expect_visit_page("page3", link("page1"), link("page2"))
+    subject.run uri(%w(page1))
+  end
+
+  it "visits all chapters once (and only once)" do
+    expect_visit_page("page1", link("page2", "chapter"))
+    expect_visit_page("page2", link("page1", "chapter"), link("page3", "chapter"))
+    expect_visit_page("page3", link("page1", "chapter"), link("page2", "chapter"))
+    subject.run uri(%w(page1))
+  end
+
+  it "visits chapters too" do
+    expect_visit_page("page1", link("page2", "chapter"))
+    expect_visit_page("page2")
+    subject.run uri(%w(page1))
+  end
+
+  it "leverages page_def to determine good links" do
+    page_def.link_path = ".good a"
+    expect_visit_page("page1", "<div class='good'>", link("good"), "</div>", link("bad"))
+    expect_visit_page("good")
+    subject.run uri(%w(page1))
+  end
+
+  it "ignores #target in url" do
+    expect_visit_page("page1", link("page1#target"))
+    subject.run uri(%w(page1))
+  end
+
+  it "skips bad urls" do
+    expect_visit_page("page1", link("%@")) # it never gets to call a second time
+    expect { subject.run uri(%w(page1)) }.to raise_error(/bad URI/)
+  end
+
+  it "uses url filter for pages" do
+    expect(invalid_urls).to receive(:include?).with(URI.parse(site("x.pdf"))).and_raise("bad file extension")
+    expect_visit_page("page1", link("x.pdf"))
+    expect { subject.run uri(%w(page1)) }.to raise_error("bad file extension")
+  end
+
+  it "uses url filter for chapters" do
+    expect(invalid_urls).to receive(:include?).with(URI.parse(site("x.pdf"))).and_raise("bad file extension")
+    expect_visit_page("page1", link("x.pdf", "chapter"))
+    expect { subject.run uri(%w(page1)) }.to raise_error("bad file extension")
+  end
+
+  context "with invalid_urls" do
+    it "skips invalid_urls" do
+      expect(subject.invalid_urls).to receive(:include?).with(uri("bad")).and_return(true)
+      expect_visit_page("page1", link("bad"))
+      subject.run uri(%w(page1))
+    end
+  end
+
+  context "logging" do
+    it "logs page visits" do
+      enable_logging
+      expect_visit_page("page1")
+      subject.run uri(%w(page1))
+      expect_to_have_logged("visit #{uri("page1")}")
+    end
+
+    it "doesnt log page visits" do
+      expect_visit_page("page1")
+      subject.run uri(%w(page1))
+      expect_to_have_logged()
+    end
+  end
+
+  private
+
+  def expect_visit_page(url, *args)
+    url = site(url)
+    expect(web).to receive(:[]).with(url.to_s).and_return(page(url, *args))
+  end
+end