audio_book_creator 0.0.1

data/lib/audio_book_creator/spider.rb

@@ -0,0 +1,60 @@
+require 'nokogiri'
+require 'uri'
+
+module AudioBookCreator
+  class Spider
+    include Logging
+
+    # @!attribute web
+    #   @return Hash access to the world wide web
+    attr_accessor :web
+    attr_accessor :invalid_urls
+
+    attr_accessor :page_def
+
+    def initialize(page_def, web = {}, invalid_urls = {})
+      @page_def     = page_def
+      @web          = web
+      @invalid_urls = invalid_urls
+    end
+
+    def run(chapters)
+      outstanding = CascadingArray.new([], chapters.map { |o| uri(o) })
+      visited = []
+
+      while (url = outstanding.shift)
+        contents, new_pages, new_chapters = visit_page(url)
+        visited << contents
+        new_pages.each do |href|
+          outstanding.add_unique_page(href) unless invalid_urls.include?(href)
+        end
+        new_chapters.each do |href|
+          outstanding.add_unique_chapter(href) unless invalid_urls.include?(href)
+        end
+      end
+      visited
+    end
+
+    private
+
+    # this one hangs on mutations
+    def visit_page(url)
+      logger.info { "visit #{url}" }
+      page = web[url.to_s]
+      doc = Nokogiri::HTML(page)
+      [
+        page,
+        page_def.page_links(doc) { |a| uri(url, a["href"]) },
+        page_def.chapter_links(doc) { |a| uri(url, a["href"]) }
+      ]
+    end
+
+    # raises URI::Error (BadURIError)
+    def uri(url, alt = nil)
+      url = URI.parse(url) unless url.is_a?(URI)
+      url += alt if alt
+      url.fragment = nil # remove #x part of url
+      url
+    end
+  end
+end

data/lib/audio_book_creator/spoken_chapter.rb

@@ -0,0 +1,16 @@
+module AudioBookCreator
+  class SpokenChapter
+    attr_accessor :title, :filename
+
+    def initialize(title, filename)
+      @title = title
+      @filename = filename
+    end
+
+    def ==(other)
+      other.kind_of?(SpokenChapter) &&
+        other.title.eql?(title) && other.filename.eql?(filename)
+    end
+    alias :eql? :==
+  end
+end

data/lib/audio_book_creator/surfer_def.rb

@@ -0,0 +1,15 @@
+module AudioBookCreator
+  class SurferDef
+    attr_accessor :host
+    attr_accessor :max
+    attr_accessor :regen_html
+    attr_accessor :cache_filename
+
+    def initialize(host = nil, max = nil, regen_html = nil, cache_filename = nil)
+      @host = host
+      @max = max
+      @regen_html = regen_html
+      @cache_filename = cache_filename
+    end
+  end
+end

data/lib/audio_book_creator/url_filter.rb

@@ -0,0 +1,33 @@
+require 'uri'
+
+module AudioBookCreator
+  class UrlFilter
+    include Logging
+    attr_accessor :host
+
+    def initialize(host)
+      self.host = host
+    end
+
+    def host=(url)
+      @host = url && (url.is_a?(URI) ? url : URI.parse(url)).host
+    end
+
+    # return true if this is invalid
+    def include?(url)
+      if !valid_extensions.include?(File.extname(url.path))
+        logger.warn { "ignoring bad file extension #{url}" }
+        raise "bad file extension"
+      elsif host && (host != url.host)
+        logger.warn { "ignoring remote url #{url}" }
+        raise "remote url #{url}"
+      end
+    end
+
+    private
+
+    def valid_extensions
+      ["", '.html', '.htm', '.php', '.jsp']
+    end
+  end
+end

data/lib/audio_book_creator/version.rb

@@ -0,0 +1,3 @@
+module AudioBookCreator
+  VERSION = "0.0.1"
+end

data/lib/audio_book_creator/web.rb

@@ -0,0 +1,44 @@
+require 'open-uri'
+require 'uri'
+
+module AudioBookCreator
+  class Web
+    include Logging
+
+    # @!attribute max
+    #   @return Integer the maximum number of pages to visit
+    attr_accessor :max
+
+    # @!attribute count
+    #   @return Integer the number of pages visited
+    attr_accessor :count
+
+    def initialize(max = nil)
+      @max = max
+      @count = 0
+    end
+
+    def [](url)
+      @count += 1
+      log_page(url)
+      check_limit
+      open(url.to_s).read
+    end
+
+    private
+
+    def log_page(url)
+      logger.info do
+        max ? "fetch  #{url} [#{count}/#{max}]" : "fetch  #{url} [#{count}]"
+      end
+    end
+
+    def check_limit
+      raise "visited #{max} pages" if over_limit?
+    end
+
+    def over_limit?
+      max && count > max
+    end
+  end
+end

data/spec/audio_book_creator/binder_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe AudioBookCreator::Binder do
+  let(:book_def) { AudioBookCreator::BookDef.new("title", nil, "dir", nil, false) }
+  let(:speaker_def) { AudioBookCreator::SpeakerDef.new(regen_audio: false) }
+  subject { described_class.new(book_def, speaker_def) }
+
+  it "should require a chapter" do
+    expect_runner.not_to receive(:system)
+    expect { subject.create([]) }.to raise_error
+  end
+
+  it "should do nothing if m4b exists" do
+    expect(File).to receive(:exist?).with("title.m4b").and_return(true)
+
+    expect_runner.not_to receive(:system)
+    subject.create([spoken_chapter])
+  end
+
+  it "should base filename on title and sanitize it" do
+    book_def.title = "the title"
+    expect_runner.not_to receive(:system)
+    expect(File).to receive(:exist?).with("the-title.m4b").and_return(true)
+    subject.create([spoken_chapter])
+  end
+
+  it "should create text and m4a file" do
+    expect(File).to receive(:exist?).with("title.m4b").and_return(false)
+
+    expect_runner.to receive(:system)
+      .with("abbinder", "-a", "Vicki", "-t", "title", "-b", "32", "-c", "1",
+            "-r", "22050", "-g", "Audiobook", "-l", "7", "-o", "title.m4b",
+            "@the title@", "dir/chapter01.m4a").and_return(true)
+    subject.create([spoken_chapter])
+  end
+
+  context "with itunes" do
+    before { book_def.itunes = true}
+    subject { described_class.new(book_def, speaker_def) }
+    it "should load into itunes" do
+      expect(File).to receive(:exist?).with("title.m4b").and_return(false)
+
+      expect_runner.to receive(:system)
+        .with("abbinder", "-a", "Vicki", "-t", "title", "-b", "32", "-c", "1",
+              "-r", "22050", "-g", "Audiobook", "-l", "7", "-o", "title.m4b",
+              "@the title@", "dir/chapter01.m4a", "-A").and_return(true)
+      subject.create([spoken_chapter])
+    end
+  end
+
+  it "outputs messages if set to verbose" do
+    enable_logging
+    expect(File).to receive(:exist?).and_return(false)
+
+    expect_runner.to receive(:system).and_return(true)
+
+    subject.create([spoken_chapter])
+    expect_to_have_logged(/^run:/, "", "","success")
+  end
+
+  it "outputs no messages if set to non verbose" do
+    expect(File).to receive(:exist?).and_return(false)
+
+    expect_runner.to receive(:system).and_return(true)
+    subject.create([spoken_chapter])
+    expect_to_have_logged()
+  end
+
+  context "with force" do
+    before { speaker_def.regen_audio = true }
+    subject { described_class.new(book_def, speaker_def) }
+
+    it "should create m4a if exists" do
+      expect(File).not_to receive(:exist?)
+
+      expect_runner.to receive(:system).and_return(true)
+      subject.create([spoken_chapter])
+    end
+  end
+
+  context "with false force" do
+    subject { described_class.new(book_def, speaker_def) }
+
+    it "should not create m4a if exists" do
+      expect(File).to receive(:exist?).and_return(true)
+
+      expect_runner.not_to receive(:system)
+      subject.create([spoken_chapter])
+    end
+  end
+
+  it "requires chapters to be passed in" do
+    expect_runner.not_to receive(:system)
+    expect { subject.create(nil) }.to raise_error("No Chapters")
+    expect { subject.create([]) }.to raise_error("No Chapters")
+  end
+
+  private
+
+  def expect_runner
+    expect_any_instance_of(AudioBookCreator::Runner)
+  end
+end

data/spec/audio_book_creator/book_creator_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe AudioBookCreator::BookCreator do
+
+  # this is kinda testing the implementation
+  context "#run" do
+    let(:spider)  { double(:spider) }
+    let(:editor)  { double(:editor) }
+    let(:speaker) { double(:speaker) }
+    let(:binder)  { double(:binder) }
+
+    subject { described_class.new(spider, editor, speaker, binder) }
+
+    it "should call all the constructors and components" do
+
+      outstanding = ["http://site.com/"]
+      page_contents = ["site.com contents"]
+      chapters = [
+        chapter("contents1", "title1", 1),
+        chapter("contents2", "title2", 2)
+      ]
+      spoken_chapters = [
+        spoken_chapter("title1", "dir/chapter01.m4a"),
+        spoken_chapter("title2", "dir/chapter02.m4a")
+      ]
+      expect(speaker).to receive(:make_directory_structure)
+      expect(spider).to receive(:run).with(outstanding).and_return(page_contents)
+      expect(editor).to receive(:parse).with(page_contents).and_return(chapters)
+      expect(speaker).to receive(:say).with(chapters.first).and_return(spoken_chapters.first)
+      expect(speaker).to receive(:say).with(chapters.last).and_return(spoken_chapters.last)
+      expect(binder).to receive(:create).with(spoken_chapters)
+
+      subject.create(outstanding)
+    end
+  end
+
+  # taken from cli
+  # context "real object" do
+  #   it "spiders the web" do
+  #     # spider:
+  #     expect_visit_page("http://site.com/", "<h1>title</h1>", "<p>contents</p>")
+  #     # speaker:
+  #     expect(File).to receive(:exist?).with("title").and_return(true)
+  #     expect(File).to receive(:exist?).with("title/chapter01.txt").and_return(true)
+  #     expect(File).to receive(:exist?).with("title/chapter01.m4a").and_return(true)
+  #     # binder
+  #     expect(File).to receive(:exist?).with("title.m4b").and_return(true)
+  #     # chain parse and run to mimic bin/audio_book_creator
+  #     subject.parse(%w(title http://site.com/ -v)).run
+  #     expect(AudioBookCreator.logger.level).to eq(Logger::INFO)
+  #   end
+  # end
+
+  # private
+
+  # # NOTE: this uses any_instance because we don't want to instantiate anything
+  # # could assign web and use a double instead
+  # def expect_visit_page(url, *args)
+  #   url = site(url)
+  #   expect_any_instance_of(AudioBookCreator::Web).to receive(:[])
+  #     .with(url).and_return(page(url, *args))
+  # end
+end

data/spec/audio_book_creator/book_def_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe AudioBookCreator::BookDef do
+  context "with no parameter" do
+    subject { described_class.new }
+    it { expect(subject.title).to eq(nil) }
+    it { expect(subject.author).to eq("Vicki") }
+    it { expect(subject.urls).to be_nil }
+    it { expect(subject.itunes).to be_falsy }
+  end
+
+  context "with title" do
+    subject { described_class.new("dir") }
+    it { expect(subject.base_dir).to eq("dir") }
+    it { expect(subject.title).to eq("dir") }
+  end
+
+  context "with all parameters" do
+    subject { described_class.new("the title", "author", "dir", %w(a b), true) }
+    it { expect(subject.base_dir).to eq("dir") }
+    it { expect(subject.title).to eq("the title") }
+    it { expect(subject.author).to eq("author") }
+    it { expect(subject.filename).to eq("the-title.m4b") }
+    it { expect(subject.urls).to eq(%w(a b)) }
+    it { expect(subject.itunes).to be_truthy }
+  end
+
+  context "with derived title" do
+    subject { described_class.new("the title", "author", nil, nil) }
+    it { expect(subject.base_dir).to eq("the-title") }
+  end
+
+  context "#unique_urls" do
+    subject { described_class.new("dir") }
+    before { subject.urls = %w(http://site.com/title http://site.com/title http://site.com/title2) }
+    it { expect(subject.unique_urls).to eq(%w(http://site.com/title http://site.com/title2)) }
+  end
+
+  context ".sanitize_filename" do
+    subject { described_class }
+    it "should join strings" do
+      expect(subject.sanitize_filename("title", "jpg")).to eq("title.jpg")
+    end
+
+    it "should handle arrays" do
+      expect(subject.sanitize_filename(%w(title jpg))).to eq("title.jpg")
+    end
+
+    it "should ignore nils" do
+      expect(subject.sanitize_filename("title", nil)).to eq("title")
+    end
+
+    it "should support titles with spaces" do
+      expect(subject.sanitize_filename(%{title ((for "you", "Amy", and "John"))})).to eq("title-for-you-Amy-and-John")
+    end
+
+    it "should support titles with extra stuff" do
+      expect(subject.sanitize_filename("title,for!")).to eq("title-for")
+    end
+  end
+end

data/spec/audio_book_creator/cached_hash_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe AudioBookCreator::CachedHash do
+  let(:cache) { {} }
+  let(:main)  { {} }
+  subject { described_class.new(cache, main) }
+
+  context "#with cached content" do
+    let(:cache) { {:key => "val"} }
+    it { expect(subject[:key]).to eq("val") }
+    it { subject[:key] ; expect(main[:key]).to be_nil }
+  end
+
+  context "#with main content" do
+    let(:main) { {:key => "val"} }
+    it { expect(subject[:key]).to eq("val") }
+    it { subject[:key] ; expect(cache[:key]).to eq("val") }
+  end
+end

data/spec/audio_book_creator/cascading_array_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe AudioBookCreator::CascadingArray do
+  let(:pages) { [:p1, :p2] }
+  let(:chapters) { [:ch1, :ch2] }
+  subject { described_class.new(pages, chapters) }
+
+  it { is_expected.to be_include(:p1) }
+  it { is_expected.to be_include(:ch2) }
+  it { is_expected.not_to be_include(:ch4) }
+
+
+  it "includes even after it is empty" do
+    4.times { subject.shift }
+    expect(subject.shift).to be_nil
+    expect(subject).to be_include(:p1)
+    expect(subject).to be_include(:ch1)
+  end
+
+  it "includes later added values" do
+    subject.add_page(:p3)
+    subject.add_chapter(:c3)
+    expect(subject.each.to_a).to eq([:p1,:p2,:p3,:ch1,:ch2,:c3])
+    expect(subject).to be_include(:p3)
+    expect(subject).to be_include(:c3)
+  end
+
+  it "takes primary before secondary" do
+    expect(subject.shift).to eq(:p1)
+    expect(subject.shift).to eq(:p2)
+    expect(subject.shift).to eq(:ch1)
+    expect(subject.shift).to eq(:ch2)
+    expect(subject.shift).to be_nil
+  end
+
+  it "enumerates" do
+    ret = []
+    subject.each { |x| ret << x }
+    expect(ret).to eq([:p1,:p2,:ch1,:ch2])
+  end
+
+  it "non block enumerates" do
+    expect(subject.each).to be_a(Enumerator)
+    expect(subject.each.to_a).to eq([:p1,:p2,:ch1,:ch2])
+  end
+
+
+  it "puts pages into primary" do
+    subject.add_page(:p3)
+    expect(subject.each.to_a).to eq([:p1,:p2,:p3,:ch1,:ch2])
+  end
+
+  it "puts non duplicate pages into primary" do
+    subject.add_unique_page(:p3)
+    subject.add_unique_page(:p3)
+    expect(subject.each.to_a).to eq([:p1,:p2,:p3,:ch1,:ch2])
+  end
+
+  it "puts non duplicate chapters into secondary" do
+    subject.add_unique_chapter(:ch3)
+    subject.add_unique_chapter(:ch3)
+    expect(subject.each.to_a).to eq([:p1,:p2,:ch1,:ch2,:ch3])
+  end
+end