audio_book_creator 0.0.1 → 0.2.0

data/spec/audio_book_creator/defaulter_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe AudioBookCreator::Defaulter do
+  # sample to use for settings
+  let(:all_settings) do
+    {
+      "www.host.com" => {
+        :title_path   => "h1.host",
+        :body_path    => "div.host",
+        :link_path    => "a.host",
+        :chapter_path => "a.chapter.host",
+      }
+    }
+  end
+
+  let(:settings)    { {} }
+  let(:page_def)    { AudioBookCreator::PageDef.new("h1.title", "div", "a.link", "a.chapter") }
+  let(:book_def)    do
+    AudioBookCreator::BookDef.new("the title", "author", "dir", %w(a b), true).tap do |bd|
+      bd.urls = %w(http://www.host.com/)
+    end
+  end
+  subject { described_class.new(page_def, book_def).tap { |d| d.settings = settings } }
+
+  describe "#initialize" do
+    it { expect(subject.page_def).to eq(page_def) }
+    it { expect(subject.book_def).to eq(book_def) }
+  end
+
+  describe "#host" do
+    it "supports empty url" do
+      book_def.urls = %w()
+      expect(subject.host).to be_nil
+    end
+
+    it { expect(subject.host).to eq("www.host.com") }
+  end
+
+  describe "#settings" do
+    # clear out settings so Defaulter can actually set it up correctly
+    before { subject.settings = nil }
+
+    it "sets filename" do
+      expect(subject.settings.filename).to eq("settings.db")
+    end
+
+    it "sets table_name" do
+      expect(subject.settings.table_name).to eq("settings")
+    end
+
+    it "sets table_name" do
+      expect(subject.settings.encode).to eq(true)
+    end
+  end
+
+  # settings => page_defs
+  describe "#load_unset_values" do
+    it "skips on nil" do
+      subject.settings = 1 # ensure this is not accessed (because host is empty)
+      book_def.urls = []
+      subject.load_unset_values
+      expect_page_def("h1.title", "div", "a.link", "a.chapter")
+    end
+
+    it "skips unknown hosts" do
+      subject.settings = {"host2.com" => {:title_path => "h1.host2"}}
+      subject.load_unset_values
+      expect_page_def("h1.title", "div", "a.link", "a.chapter")
+    end
+
+    it "uses a) hostname to b) set partial values" do
+      subject.settings = {"www.host.com" => {:title_path => "h1.host"}}
+      book_def.urls = %w(http://www.host.com/abc)
+      subject.load_unset_values
+      expect_page_def("h1.host", "div", "a.link", "a.chapter")
+    end
+
+    it "sets all values" do
+      subject.settings = all_settings
+      subject.load_unset_values
+      expect_page_def("h1.host", "div.host", "a.host", "a.chapter.host")
+    end
+  end
+
+  # page_defs => settings
+  describe "#store" do
+    let(:settings) { all_settings }
+    let(:page_def) { AudioBookCreator::PageDef.new(nil, nil, nil, nil) }
+
+    it "skips on empty url" do
+      subject.settings = 1 # ensure this is not accessed (because host is empty)
+      book_def.urls = []
+      expect { subject.store }.not_to raise_error
+    end
+
+    context "with unknown host" do
+      let(:settings) { {} }
+
+      it "adds settings" do
+        # no settings for this host
+        page_def.title_path = "h1.changed"
+        subject.store
+        expect_settings("h1.changed")
+      end
+    end
+
+    it "updates only overridden values" do
+      page_def.title_path = "h1.changed"
+      subject.store
+      expect_settings("h1.changed", "div.host", "a.host", "a.chapter.host")
+    end
+
+    it "sets all values" do
+      page_def.title_path   = "h1.changed"
+      page_def.body_path    = "div.changed"
+      page_def.link_path    = "a.changed"
+      page_def.chapter_path = "a.chapter.changed"
+      subject.store
+      expect_settings("h1.changed", "div.changed", "a.changed", "a.chapter.changed")
+    end
+  end
+
+  def expect_page_def(title_path, body_path, link_path, chapter_path)
+    expect(page_def.title_path).to eq(title_path)
+    expect(page_def.body_path).to eq(body_path)
+    expect(page_def.link_path).to eq(link_path)
+    expect(page_def.chapter_path).to eq(chapter_path)
+  end
+
+  def expect_settings(title_path = nil, body_path = nil, link_path = nil, chapter_path = nil)
+    value = settings[subject.host]
+    expect(value).not_to be_nil
+    if title_path
+      expect(value[:title_path]).to eq(title_path)
+    else
+      expect(value).not_to have_key(:title_path)
+    end
+    if body_path
+      expect(value[:body_path]).to eq(body_path)
+    else
+      expect(value).not_to have_key(:body_path)
+    end
+    if link_path
+      expect(value[:link_path]).to eq(link_path)
+    else
+      expect(value).not_to have_key(:link_path)
+    end
+    if chapter_path
+      expect(value[:chapter_path]).to eq(chapter_path)
+    else
+      expect(value).not_to have_key(:chapter_path)
+    end
+  end
+end

data/spec/audio_book_creator/editor_spec.rb

@@ -5,7 +5,7 @@ describe AudioBookCreator::Editor do
   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>",
+    expect(subject.parse([web_page(uri("page1"), "page1", "<h1>the title</h1>",
                                "<p>first</p>", "<p>second</p>")
                          ])).to eq([chapter1])
   end
@@ -13,27 +13,27 @@ describe AudioBookCreator::Editor do
   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>",
+    expect(subject.parse([web_page(uri("page1"), "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>",
+    expect(subject.parse([web_page(uri("page1"), "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>"),
+    expect(subject.parse([web_page(uri("page1"), "page1", "<h1>p1</h1>", "<p>first</p>"),
+                          web_page(uri("page2"), "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>"),
+    expect(subject.parse([web_page(uri("page1"), "page1", "<p>first</p>"),
+                          web_page(uri("page2"), "page2", "<p>second</p>"),
                          ])).to eq([chapter("first", "Chapter 1", 1), chapter("second", "Chapter 2", 2)])
   end
 end

data/spec/audio_book_creator/page_db_spec.rb

@@ -2,11 +2,12 @@ require "spec_helper"
 require 'tempfile'
 
 describe AudioBookCreator::PageDb do
-  subject { described_class.new(":memory:") }
+  subject { standard_db }
 
   # all of these tests are in memory
   # this is the only test that depends upon it
   context "with memory databases" do
+    subject { standard_db(":memory:")}
     it "does not create a file" do
       # access key to trigger database creation
       subject["key"]
@@ -14,30 +15,84 @@ describe AudioBookCreator::PageDb do
     end
   end
 
+  describe "#initialize" do
+    subject { described_class.new(":memory:", "tablename", true) }
+    it { expect(subject.filename).to eq(":memory:") }
+    it { expect(subject.table_name).to eq("tablename") }
+    it { expect(subject.encode).to eq(true) }
+  end
+
   it "works" do
     expect(subject).not_to be_nil
   end
 
-  it "creates cache value" do
-    subject["key"] = "value"
+  describe "#[]" do
+    it "finds value" do
+      subject["key"] = "value"
+
+      expect(subject["key"]).to eq("value")
+    end
+
+    it "finds nothing" do
+      expect(subject["key"]).to be_nil
+    end
+
+    context "with encoding db" do
+      subject { encoded_db }
+      it "find hashes" do
+        subject["key"] = {:name => "value"}
 
-    expect(subject["key"]).to eq("value")
+        expect(subject["key"]).to eq({:name => "value"})
+      end
+    end
   end
 
-  it "include good key" do
-    subject["key"] = "value"
-    expect(subject).to include("key")
+  describe "#[]=" do
+    it "sets nils" do
+      subject["key"] = nil
+
+      expect(subject["key"]).to eq(nil)
+    end
+
+    it "sets value" do
+      subject["key"] = "value"
+
+      expect(subject["key"]).to eq("value")
+    end
+
+    context "with encoding db" do
+      subject { encoded_db }
+
+      it "sets nils" do
+        subject["key"] = nil
+
+        expect(subject["key"]).to eq(nil)
+      end
+
+      it "sets hashes" do
+        subject["key"] = {:name => "value"}
+
+        expect(subject["key"]).to eq({:name => "value"})
+      end
+    end
   end
 
-  it "doesnt include bad key" do
-    expect(subject).not_to include("key")
+  describe "#include?" do
+    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
   end
 
   context "with prepopulated (file) database" do
     let(:tmp) { Tempfile.new("db") }
 
     before do
-      db = described_class.new(tmp.path)
+      db = standard_db(tmp.path)
       db["key"] = "value"
     end
 
@@ -47,7 +102,7 @@ describe AudioBookCreator::PageDb do
     end
 
     it "finds entry in previously created cache" do
-      db = described_class.new(tmp.path)
+      db = standard_db(tmp.path)
       expect(db["key"]).to eq("value")
     end
 
@@ -71,4 +126,11 @@ describe AudioBookCreator::PageDb do
     expect(subject.map { |(n, v)| "#{n}:#{v}" }).to eq(%w(keyc:v keya:v keyz:v))
   end
 
+  def standard_db(filename = ":memory:")
+    described_class.new(filename, "pages", false)
+  end
+
+  def encoded_db(filename = ":memory:")
+    described_class.new(filename, "settings", true)
+  end
 end

data/spec/audio_book_creator/page_def_spec.rb

@@ -10,69 +10,55 @@ describe AudioBookCreator::PageDef do
   end
 
   context "with all parameters" do
-    subject { described_class.new("h1.title", "div", "a.link", "a.chapter") }
+    subject { described_class.new("h1.title", "div", "a.link", "a.chapter", {:url => true}) }
     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
+    it { expect(subject.invalid_urls).to eq({:url => true}) }
   end
 
   describe "#page_links" do
+    let(:root) { uri("") }
     context "with no page_links" do
-      let(:page) { dom("<p></p>")}
-      it { expect(subject.page_links(page){ |r| r["href"] }).to be_empty}
+      let(:wp) { web_page(root, "title","<p></p>")}
+      it { expect(subject.page_links(wp)).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))}
+      let(:wp) { web_page(root, "title", "<a href='tgt1'>a</a><a href='tgt2'>a</a>")}
+      it { expect(subject.page_links(wp)).to eq(uri(%w(tgt1 tgt2))) }
+    end
+    context "with bad page_links" do
+      before { subject.invalid_urls = {uri("bad") => false}}
+      let(:wp) { web_page(root, "title", "<a href='tgt1'>a</a><a href='bad'>a</a>")}
+      it { expect(subject.page_links(wp)).to eq(uri(%w(tgt1))) }
     end
   end
 
   describe "#chapter_links" do
+    let(:root) { uri("") }
     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 }
+      let(:wp) { web_page(root, "title","<p></p>")}
+      it { expect(subject.chapter_links(wp)).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 }
+      let(:wp) { web_page(root, "title", "<p><a href='x'>x</a></p>")}
+      it { expect(subject.chapter_links(wp)).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)) }
+      let(:wp) { web_page(root, "title", "<a class='chapter' href='tgt1'>a</a><a class='chapter' href='tgt2'>a</a>") }
+      it { expect(subject.chapter_links(wp)).to eq(uri(%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 }
+      let(:wp) { web_page(root, "title", "<a class='chapter' href='tgt1'>a</a><a class='chapter' href='tgt2'>a</a>") }
+      it { expect(subject.chapter_links(wp)).to be_empty }
+    end
+    context "with bad chapter_links" do
+      before { subject.invalid_urls = {uri("bad") => false}}
+      let(:wp) { web_page(root, "title", "<a class='chapter' href='tgt1'>a</a><a class='chapter' href='bad'>a</a>")}
+      it { expect(subject.chapter_links(wp)).to eq(uri(%w(tgt1))) }
     end
   end
 end

data/spec/audio_book_creator/speaker_spec.rb

@@ -6,7 +6,7 @@ describe AudioBookCreator::Speaker do
   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
+    expect { subject.say(chapter(nil)) }.to raise_error("Empty Chapter")
   end
 
   it "should do nothing if txt and mp4 file exist" do
@@ -61,7 +61,7 @@ describe AudioBookCreator::Speaker do
 
   it "should freak if no chapters are passed in" do
     expect_runner.not_to receive(:system)
-    expect { subject.say([]) }.to raise_error("Empty chapter")
+    expect { subject.say([]) }.to raise_error("Empty Chapter")
   end
 
   context "#make_directory_structure" do

data/spec/audio_book_creator/spider_spec.rb

@@ -2,47 +2,40 @@ 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(:page_def) { AudioBookCreator::PageDef.new("h1", "p", "a.page", "a.chapter", invalid_urls) }
   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
+  subject { described_class.new(page_def, web) }
 
   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")])
+      expect(subject.run(uri(%w(page1)))).to eq([web_page(uri("page1"), 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")])
+      expect(subject.run(site(%w(page1)))).to eq([web_page(uri("page1"), 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"))])
+        .to eq([web_page(uri("page1"), site("page1")), web_page(uri("page2"), 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"))])
+        .to eq([web_page(uri("page1"), site("page1"),link("page2"), link("page2")), web_page(uri("page2"), site("page2"))])
     end
 
     it "skips loops from uri" do
@@ -88,7 +81,9 @@ describe AudioBookCreator::Spider 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"))])
+    expect(subject.run uri(%w(page1))).to eq([
+      web_page(uri("page1"), site("page1"), *p1_contents),
+      web_page(uri("page2"), site("page2"))])
   end
 
   it "visits all pages once (and only once)" do
@@ -142,7 +137,7 @@ describe AudioBookCreator::Spider do
 
   context "with invalid_urls" do
     it "skips invalid_urls" do
-      expect(subject.invalid_urls).to receive(:include?).with(uri("bad")).and_return(true)
+      expect(invalid_urls).to receive(:include?).with(uri("bad")).and_return(true)
       expect_visit_page("page1", link("bad"))
       subject.run uri(%w(page1))
     end