audio_book_creator 0.0.1 → 0.2.0

data/lib/audio_book_creator/page_db.rb

@@ -1,30 +1,36 @@
 require "sqlite3"
+require "json"
 
 module AudioBookCreator
+  # a name value store stored in sqlite
+  # this is used for pages and also settings
   class PageDb
     include Enumerable
 
-    # this is for tests - get out of here
-    attr_accessor :filename
+    attr_accessor :filename, :table_name, :encode
 
-    def initialize(filename)
+    def initialize(filename, table_name, encode)
       @filename = filename
+      @table_name = table_name
+      @encode = encode
     end
 
     def []=(key, value)
-      db.execute "insert into pages (name, contents) values ( ?, ?)", [key, value]
+      value = JSON.generate(value) if encode && value
+      db.execute "insert into #{table_name} (name, contents) values (?, ?)", [key, value]
     end
 
     def [](key)
-      db.execute("select contents from pages where name = ?", key).map { |row| row.first }.first
+      value = db.execute("select contents from #{table_name} where name = ?", key).map { |row| row.first }.first
+      encode && value ? JSON.parse(value, :symbolize_names => true) : value
     end
 
     def include?(key)
-      !!self[key]
+      self[key]
     end
 
     def each(&block)
-      db.execute "select name, contents from pages order by rowid", &block
+      db.execute "select name, contents from #{table_name}", &block
     end
 
     private
@@ -35,7 +41,7 @@ module AudioBookCreator
 
     def create
       SQLite3::Database.new(filename).tap do |db|
-        db.execute("create table if not exists pages (name text, contents blob)")
+        db.execute("create table if not exists #{table_name} (name text, contents blob)")
       end
     end
   end

data/lib/audio_book_creator/page_def.rb

@@ -2,30 +2,22 @@ module AudioBookCreator
   # information on the format of the html page that is read
   class PageDef
     attr_accessor :title_path, :body_path, :link_path, :chapter_path
+    attr_accessor :invalid_urls
 
-    def initialize(title_path = "h1", body_path = "p", link_path = "a", chapter_path = nil)
+    def initialize(title_path = "h1", body_path = "p", link_path = "a", chapter_path = nil, invalid_urls = {})
       @title_path = title_path
       @body_path = body_path
       @link_path = link_path
       @chapter_path = chapter_path
+      @invalid_urls = invalid_urls
     end
 
-    def title(dom)
-      title = dom.css(title_path).first
-      title.text if title
+    def page_links(page)
+      page.links(link_path).select { |href| !invalid_urls.include?(href) }
     end
 
-    def body(dom)
-      dom.css(body_path)
-      # feels like I need .map { |n| n.text }
-    end
-
-    def page_links(dom, &block)
-      dom.css(link_path).map(&block)
-    end
-
-    def chapter_links(dom, &block)
-      dom.css(chapter_path).map(&block)
+    def chapter_links(page)
+      page.links(chapter_path).select { |href| !invalid_urls.include?(href) }
     end
   end
 end

data/lib/audio_book_creator/runner.rb

@@ -4,11 +4,13 @@ module AudioBookCreator
     include Logging
 
     def run(cmd, options)
-      params = options[:params].flatten.flatten.compact
+      params = options.fetch(:params).flatten.flatten.compact
 
-      logger.info { "run: #{cmd} #{params.join(" ")}" }
+      cmdline = [cmd] + params.map(&:to_s)
+
+      logger.info { "run: #{cmdline.join(" ")}" }
       logger.info ""
-      status = system(cmd, *params.map { |x| x.to_s })
+      status = system(*cmdline)
       logger.info ""
       logger.info { status ? "success" : "issue" }
 

data/lib/audio_book_creator/speaker.rb

@@ -13,7 +13,7 @@ module AudioBookCreator
     end
 
     def say(chapter)
-      raise "Empty chapter" if chapter.empty?
+      raise "Empty Chapter" if chapter.empty?
       text_filename = chapter_text_filename(chapter)
       sound_filename = chapter_sound_filename(chapter)
 

data/lib/audio_book_creator/spider.rb

@@ -1,6 +1,3 @@
-require 'nokogiri'
-require 'uri'
-
 module AudioBookCreator
   class Spider
     include Logging
@@ -8,28 +5,26 @@ module AudioBookCreator
     # @!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 = {})
+    def initialize(page_def, web)
       @page_def     = page_def
       @web          = web
-      @invalid_urls = invalid_urls
     end
 
     def run(chapters)
-      outstanding = CascadingArray.new([], chapters.map { |o| uri(o) })
+      outstanding = CascadingArray.new([], WebPage.map_urls(chapters))
       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)
+        wp = visit_page(url)
+        visited << wp
+        page_def.page_links(wp).each do |href|
+          outstanding.add_unique_page(href)
         end
-        new_chapters.each do |href|
-          outstanding.add_unique_chapter(href) unless invalid_urls.include?(href)
+        page_def.chapter_links(wp).each do |href|
+          outstanding.add_unique_chapter(href)
         end
       end
       visited
@@ -40,21 +35,7 @@ module AudioBookCreator
     # 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
+      WebPage.new(url, web[url.to_s])
     end
   end
 end

data/lib/audio_book_creator/surfer_def.rb

@@ -1,15 +1,11 @@
 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
+    def initialize(max = nil, regen_html = nil)
       @max = max
       @regen_html = regen_html
-      @cache_filename = cache_filename
     end
   end
 end

data/lib/audio_book_creator/url_filter.rb

@@ -27,7 +27,7 @@ module AudioBookCreator
     private
 
     def valid_extensions
-      ["", '.html', '.htm', '.php', '.jsp']
+      ["", '.html', '.htm', '.php', '.jsp', '.cfm']
     end
   end
 end

data/lib/audio_book_creator/version.rb

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

data/lib/audio_book_creator/web_page.rb

@@ -0,0 +1,49 @@
+require 'nokogiri'
+require 'uri'
+
+module AudioBookCreator
+  class WebPage
+    attr_accessor :url
+    attr_accessor :body
+    #attr_accessor :etag
+
+    def initialize(url, body)
+      @url = url
+      @body = body
+    end
+
+    # def single_css(path) ; css(path).first ; end
+    def css(path)
+      dom.css(path).map {|n| n.text }
+    end
+
+    def links(path)
+      dom.css(path).map { |a| self.class.uri(url, a["href"]) }
+    end
+
+    def dom
+      @dom ||= Nokogiri::HTML(body)
+    end
+    private :dom
+
+    def ==(other)
+      other.kind_of?(WebPage) &&
+        other.url.eql?(url)
+    end
+    alias :eql? :==
+
+    def self.map_urls(url)
+      url.map { |o| uri(o) }
+    end
+
+    private
+
+    # raises URI::Error (BadURIError)
+    def self.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/run_mutant

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+class Mutt
+  FILE_NAME="audio_book_creator"
+  attr_accessor :src
+  attr_accessor :spec
+  attr_accessor :mutant
+  attr_accessor :class_name
+
+  def initialize(src)
+    @src = src
+    @spec = src.sub("lib/","spec/").sub(".rb","_spec.rb")
+    @mutant = src.sub("lib/","muts/").sub(".rb",".txt")
+    @class_name = file_to_class(src.sub("lib/",""))
+  end
+
+  def need_to_run?
+    !File.exist?(mutant) ||
+    File.stat(src).mtime > File.stat(mutant).mtime ||
+    File.stat(spec).mtime > File.stat(mutant).mtime
+  end
+
+  def skip?
+    class_name.include?("::Version")
+  end
+
+  def ensure_mutant_dir
+    FileUtils.mkdir_p(File.dirname(mutant))
+  end
+
+  def mutant_count
+    if File.exist?(mutant)
+      %w(Kills Mutations).map { |field| `awk "/#{field}/ { print \\$2; }" #{mutant}`.chomp.to_i }
+    else
+      ["", ""]
+    end
+  end
+
+  def count_in_progress
+    k, m = mutant_count
+    "%s%4s/%4s  #{class_name}" % ["?", k, m]
+  end
+
+  def counts
+    k, m = mutant_count
+    "%s%4s/%4s  #{class_name}" % [(k == m ? " " : "*"), k, m]
+  end
+
+  def run_mutant
+    # ensure_mutant_dir
+    # --fail-fast
+    system({ "MUTANT" => "true"},
+      "bundle exec mutant --include lib --require #{FILE_NAME} --require audio_book_creator/cli " +
+      "--use rspec #{class_name} --jobs 1 > #{mutant}")
+  rescue SystemExit, Interrupt
+    FileUtils.rm(mutant)
+    raise
+  end
+
+  def self.run(filenames, force)
+    filenames.map { |src| Mutt.new(src) }.select { |mutant| !mutant.skip? }.each do |mutant|
+      if force || mutant.need_to_run?
+        puts "#{mutant.count_in_progress} ..."
+        mutant.run_mutant
+        print back_a_line
+        puts "#{mutant.counts}    "
+      else
+        puts mutant.counts
+      end
+    end
+  end
+
+  private
+
+  def self.back_a_line
+    @back_a_line ||= `tput cuu1; tput el`
+  end
+
+  def file_to_class(str)
+    str.sub(".rb","").split("/").collect { |f| f.split("_").collect(&:capitalize).join }.join("::")
+  end
+end
+
+force = ARGV.delete("-f")
+filenames = ARGV.empty? ? Dir["lib/**/*.rb"] : ARGV
+
+Mutt.run(filenames, force)

data/spec/audio_book_creator/binder_spec.rb

@@ -7,7 +7,7 @@ describe AudioBookCreator::Binder do
 
   it "should require a chapter" do
     expect_runner.not_to receive(:system)
-    expect { subject.create([]) }.to raise_error
+    expect {subject.create([]) }.to raise_error("No Chapters")
   end
 
   it "should do nothing if m4b exists" do
@@ -41,9 +41,9 @@ describe AudioBookCreator::Binder 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",
+        .with("abbinder", "-A", "-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)
+              "@the title@", "dir/chapter01.m4a").and_return(true)
       subject.create([spoken_chapter])
     end
   end

data/spec/audio_book_creator/book_creator_spec.rb

@@ -12,9 +12,8 @@ describe AudioBookCreator::BookCreator do
     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"]
+      outstanding = [AudioBookCreator::WebPage.new('', "http://site.com/")]
+      page_contents = [page("title1","contents1"), page("title2","contents2")]
       chapters = [
         chapter("contents1", "title1", 1),
         chapter("contents2", "title2", 2)

data/spec/audio_book_creator/book_def_spec.rb

@@ -6,7 +6,7 @@ describe AudioBookCreator::BookDef do
     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 }
+    it { expect(subject.itunes).to be_truthy }
   end
 
   context "with title" do
@@ -16,18 +16,38 @@ describe AudioBookCreator::BookDef do
   end
 
   context "with all parameters" do
-    subject { described_class.new("the title", "author", "dir", %w(a b), true) }
+    subject { described_class.new("the title", "author", "dir", %w(a b), false) }
     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_falsy }
+  end
+
+  context "with all parameters alt" do
+    subject { described_class.new("the title", "author", "dir", %w(a b), true) }
     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") }
+  describe "#base_dir (derived)" do
+    subject { described_class.new }
+
+    it "supports titles with spaces" do
+      subject.title = %{title ((for "you", "Amy", and "John"))}
+      expect(subject.base_dir).to eq("title-for-you-Amy-and-John")
+    end
+
+    it "supports titles with extra stuff" do
+      subject.title = "title,for!"
+      expect(subject.base_dir).to eq("title-for")
+    end
+
+    it "overrides" do
+      subject.base_dir = "dir"
+      subject.title = "title"
+      expect(subject.base_dir).to eq("dir")
+    end
   end
 
   context "#unique_urls" do
@@ -36,26 +56,17 @@ describe AudioBookCreator::BookDef do
     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
+  describe "#filename (derived)" do
+    subject { described_class.new }
 
-    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")
+    it "adds extension" do
+      subject.title = "title"
+      expect(subject.filename).to eq("title.m4b")
     end
 
-    it "should support titles with extra stuff" do
-      expect(subject.sanitize_filename("title,for!")).to eq("title-for")
+    it "supports spaces" do
+      subject.title = "the title"
+      expect(subject.filename).to eq("the-title.m4b")
     end
   end
 end