rpub 0.4.0 → 0.5.0

data/lib/rpub/document.rb

@@ -0,0 +1,68 @@
+module Rpub
+  class Document
+    KRAMDOWN_OPTIONS = {
+      :coderay_line_numbers => nil
+    }
+
+    OutlineElement = Struct.new(:level, :text, :html_id)
+
+    def initialize(content, layout)
+      @document = Kramdown::Document.new(content, KRAMDOWN_OPTIONS.merge(:template => layout))
+    end
+
+    # @return [Kramdown::Element] Toc elements hierarchy
+    def toc
+      Kramdown::Converter::Toc.convert(document.root).first
+    end
+
+    # Ordered headers for this chapter, each header as an object responding
+    # to #level and #text.
+    #
+    # @return [Array<#text,#level,#html_id>] list of headers for this chapter
+    def outline
+      @outline ||= elements(:header).map do |element|
+        OutlineElement.new(
+          element.options[:level],
+          element_text(element),
+          Kramdown::Converter::Html.send(:new, document, { :auto_id_prefix => '' }).generate_id(element.options[:raw_text])
+        )
+      end
+    end
+
+    # @return [String] content parsed to HTML by the markdown engine.
+    def to_html
+      @to_html ||= Typogruby.improve(@document.to_html)
+    end
+
+    # @return [String] Text of the first heading in this chapter
+    def title
+      @title ||= begin
+        (heading = outline.first) ? heading.text : 'untitled'
+      end
+    end
+
+    # @return [Array<String>] list of all image references
+    def images
+      @images ||= elements(:img).map { |e| e.attr['src'] }
+    end
+
+    private
+
+    attr_reader :document
+
+    def element_text(element)
+      elements(:text, element).map { |e| e.value }.join
+    end
+
+    def elements(type, root = @document.root)
+      collector = lambda do |element|
+        element.children.select { |e|
+          e.type == type
+        } + element.children.map { |e|
+          collector.call(e)
+        }.flatten
+      end
+      collector.call(root)
+    end
+  end
+end

data/lib/rpub/epub.rb

@@ -1,5 +1,6 @@
 module Rpub
   class Epub
+    include Rpub.source
     attr_reader :book, :styles
 
     def initialize(book, styles)
@@ -9,26 +10,26 @@ module Rpub
     def manifest_in(target)
       target.store_file 'mimetype', 'application/epub+zip'
       target.compress_file 'META-INF/container.xml', Container.new
-      target.compress_file 'OEBPS/content.opf', Content.new(book)
-      target.compress_file 'OEBPS/toc.ncx', Toc.new(book)
-      target.compress_file 'OEBPS/styles.css', styles
+      target.compress_file 'OEBPS/content.opf',      Content.new(book)
+      target.compress_file 'OEBPS/toc.ncx',          Toc.new(book)
+      target.compress_file 'OEBPS/styles.css',       styles
       if book.has_cover?
         target.compress_file 'OEBPS/cover.html', Cover.new(book)
-        target.compress_file File.join('OEBPS', book.cover_image), File.read(book.cover_image)
+        target.compress_file File.join('OEBPS', book.config.cover_image), read(book.config.cover_image)
       end
       if book.has_toc?
         target.compress_file 'OEBPS/toc.html', toc { HtmlToc.new(book).render }
       end
       if book.has_fonts?
         book.fonts.each do |font|
-          target.compress_file File.join('OEBPS', font), File.read(font)
+          target.compress_file File.join('OEBPS', font), read(font)
         end
       end
       book.each do |chapter|
         target.compress_file File.join('OEBPS', chapter.filename), chapter.to_html
       end
       book.images.each do |image|
-        target.compress_file File.join('OEBPS', image), File.read(image)
+        target.compress_file File.join('OEBPS', image), read(image)
       end
     end
 
@@ -36,7 +37,7 @@ module Rpub
 
     def toc
       @body = yield
-      ERB.new(File.read(book.layout)).result(binding)
+      ERB.new(read(book.layout)).result(binding)
     end
   end
 end

data/lib/rpub/epub/content.rb

@@ -1,33 +1,19 @@
 module Rpub
   class Epub
     class Content < XmlFile
-      attr_reader :book
-
-      MEDIA_TYPES = {
-        'png' => 'image/png',
-        'gif' => 'image/gif',
-        'jpg' => 'image/jpeg',
-        'svg' => 'image/svg+xml'
-      }
-
-      def initialize(book)
-        @book = book
-        super()
-      end
-
       def render
         xml.instruct!
         xml.declare! :DOCTYPE, :package, :PUBLIC,  '-//W3C//DTD XHTML 1.1//EN', 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
         xml.package 'xmlns' => 'http://www.idpf.org/2007/opf', 'unique-identifier' => 'BookId', 'version' => '2.0' do
           xml.metadata 'xmlns:dc' => 'http://purl.org/dc/elements/1.1/', 'xmlns:opf' => 'http://www.idpf.org/2007/opf' do
-            xml.dc :language,    book.language
-            xml.dc :title,       book.title
-            xml.dc :creator,     book.creator, 'opf:role' => 'aut'
-            xml.dc :publisher,   book.publisher
-            xml.dc :subject,     book.subject
+            xml.dc :language,    book.config.language
+            xml.dc :title,       book.config.title
+            xml.dc :creator,     book.config.creator, 'opf:role' => 'aut'
+            xml.dc :publisher,   book.config.publisher
+            xml.dc :subject,     book.config.subject
             xml.dc :identifier,  book.uid, :id => 'BookId'
-            xml.dc :rights,      book.rights
-            xml.dc :description, book.description
+            xml.dc :rights,      book.config.rights
+            xml.dc :description, book.config.description
 
             if book.has_cover?
               xml.meta :name => 'cover', :content => 'cover-image'
@@ -46,11 +32,11 @@ module Rpub
 
             if book.has_cover?
               xml.item 'id' => 'cover', 'href' => 'cover.html', 'media-type' => 'application/xhtml+xml'
-              xml.item 'id' => 'cover-image', 'href' => book.cover_image, 'media-type' => guess_media_type(book.cover_image)
+              xml.item 'id' => 'cover-image', 'href' => book.config.cover_image, 'media-type' => MediaType.guess_media_type(book.config.cover_image)
             end
 
             book.images.each do |image|
-              xml.item 'id' => File.basename(image), 'href' => image, 'media-type' => guess_media_type(image)
+              xml.item 'id' => File.basename(image), 'href' => image, 'media-type' => MediaType.guess_media_type(image)
             end
 
             if book.has_toc?
@@ -83,13 +69,6 @@ module Rpub
           end
         end
       end
-
-      private
-
-      # TODO refactor into separate guesser object
-      def guess_media_type(filename)
-        MEDIA_TYPES.fetch(filename[/\.(gif|png|jpe?g|svg)$/, 1]) { 'image/png' }
-      end
     end
   end
 end

data/lib/rpub/epub/cover.rb

@@ -1,13 +1,6 @@
 module Rpub
   class Epub
     class Cover < XmlFile
-      attr_reader :book
-
-      def initialize(book)
-        @book = book
-        super()
-      end
-
       def render
         xml.declare! :DOCTYPE, :html, :PUBLIC, '-//W3C//DTD XHTML 1.0 Strict//EN', 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
         xml.html :xmlns => 'http://www.w3.org/1999/xhtml' do
@@ -17,7 +10,7 @@ module Rpub
           end
           xml.body do
             xml.div :id => 'cover-image' do
-              xml.img :src => book.cover_image, :alt => book.title
+              xml.img :src => book.config.cover_image, :alt => book.config.title
             end
           end
         end

data/lib/rpub/epub/html_toc.rb

@@ -1,21 +1,16 @@
 module Rpub
   class Epub
     class HtmlToc < XmlFile
-      attr_reader :book
-
-      def initialize(book)
-        @book = book
-        super()
-      end
-
       def render
         xml.div :id => 'toc' do
           xml.h1 'Table of Contents'
           xml.div :class => 'toc' do
             book.outline.each do |(filename, headings)|
               headings.each do |heading|
-                xml.div :class => "level-#{heading.level}" do
-                  xml.a heading.text, :href => [filename, heading.html_id].join('#')
+                if heading.level <= (book.config.max_level || 2)
+                  xml.div :class => "level-#{heading.level}" do
+                    xml.a heading.text, :href => [filename, heading.html_id].join('#')
+                  end
                 end
               end
             end

data/lib/rpub/epub/toc.rb

@@ -1,26 +1,17 @@
 module Rpub
   class Epub
     class Toc < XmlFile
-      attr_reader :book
-
-      def initialize(book)
-        @book       = book
-        @play_order = -1
-        @max_level  = book.config.fetch(:max_level) { 2 }
-        super()
-      end
-
       def render
         xml.instruct!
         xml.declare! :DOCTYPE, :ncx, :PUBLIC, "-//W3C//DTD XHTML 1.1//EN", 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
         xml.ncx :xmlns => 'http://www.daisy.org/z3986/2005/ncx/', :version => '2005-1' do
           xml.head do
             xml.meta :name => 'dtb:uid',            :content => book.uid
-            xml.meta :name => 'dtb:depth',          :content => @max_level
+            xml.meta :name => 'dtb:depth',          :content => max_level
             xml.meta :name => 'dtb:totalPageCount', :content => '0'
             xml.meta :name => 'dtb:maxPageNumber',  :content => '0'
           end
-          xml.docTitle { xml.text book.title }
+          xml.docTitle { xml.text book.config.title }
           xml.navMap do
             book.chapters.each do |chapter|
               nav_points_nested_by_level chapter.toc, chapter.filename
@@ -31,15 +22,27 @@ module Rpub
 
       private
 
+      def max_level
+        book.config.max_level || 2
+      end
+
+      def play_order
+        @play_order ||= 0
+      end
+
+      def play_order=(v)
+        @play_order = v
+      end
+
       def next_play_order
-        @play_order += 1
+        self.play_order = play_order + 1
       end
 
       def nav_points_nested_by_level(heading, filename, level = 1)
         heading.children.each do |heading|
           html_id = heading.attr[:id]
           source = filename+'#'+html_id
-          if heading.value.options[:level] <= @max_level
+          if heading.value.options[:level] <= max_level
             nav_point html_id, next_play_order, heading.value.options[:raw_text], source do
                 nav_points_nested_by_level heading, filename, level + 1
             end

data/lib/rpub/filesystem_source.rb

@@ -0,0 +1,47 @@
+module Rpub
+  module FilesystemSource
+    module_function
+
+    def read(filename)
+      File.read(filename)
+    end
+
+    def exists?(filename)
+      File.exists?(filename)
+    end
+
+    def source_files
+      Dir['*{.md,.markdown,.mdown,.markd}']
+    end
+
+    def write(filename, content, force = false)
+      return if content.nil?
+      if !force && File.exist?(filename)
+        warn "Not overriding #{filename}"
+        return
+      end
+      File.open(filename, 'w') do |f|
+        f.write content
+      end
+    end
+
+    def force_write(filename, content)
+      write filename, content, true
+    end
+
+    def remove(filename, dry_run = false)
+      if File.exist?(filename)
+        if dry_run
+          puts filename
+        else
+          File.unlink(filename)
+        end
+      end
+    end
+
+    def own_or_support_file(filename)
+      return filename if exists?(filename)
+      Rpub.support_file(filename)
+    end
+  end
+end

data/lib/rpub/media_type.rb

@@ -0,0 +1,16 @@
+module Rpub
+  module MediaType
+    MEDIA_TYPES = {
+      'png' => 'image/png',
+      'gif' => 'image/gif',
+      'jpg' => 'image/jpeg',
+      'svg' => 'image/svg+xml'
+    }
+
+    module_function
+
+    def guess_media_type(filename)
+      MEDIA_TYPES.fetch(filename[/\.(gif|png|jpe?g|svg)$/, 1]) { 'image/png' }
+    end
+  end
+end

data/lib/rpub/preview.rb

@@ -0,0 +1,29 @@
+module Rpub
+  class Preview
+    attr_reader :context, :source
+
+    def initialize(context, source)
+      @context, @source = context, source
+    end
+
+    def formatted
+      return unless context.chapter_files.any?
+      move_styles_inline(plain)
+    end
+
+    def text
+      Nokogiri::HTML(plain).xpath('//text()').to_s
+    end
+
+    private
+
+    def plain
+      Rpub.document_factory.call(context.chapter_files.join("\n"), context.layout).to_html
+    end
+
+    def move_styles_inline(html)
+      style_block = %Q{<style>\n#{source.read(context.styles)}\n</style>}
+      html.gsub %r{</head>}, style_block + "\n</head>"
+    end
+  end
+end

data/lib/rpub/version.rb

@@ -1,3 +1,3 @@
 module Rpub
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/rpub/xml_file.rb

@@ -3,8 +3,11 @@ module Rpub
     # @return [Builder::XmlMarkup]
     attr_reader :xml
 
-    def initialize
+    attr_reader :book
+
+    def initialize(book = nil)
       @xml = Builder::XmlMarkup.new :indent => 2
+      @book = book
     end
 
     # @return [String] render this file and output as string

data/rpub.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require './lib/rpub/version'
+require File.expand_path('../lib/rpub/version', __FILE__)
 
 Gem::Specification.new do |s|
   # Metadata
@@ -42,14 +42,13 @@ EOS
   s.add_runtime_dependency 'builder'
   s.add_runtime_dependency 'nokogiri'
   s.add_runtime_dependency 'textstats'
-  s.add_runtime_dependency 'typogruby'
+  s.add_runtime_dependency 'commander'
   s.add_development_dependency 'yard'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'guard'
-  s.add_development_dependency 'guard-rspec'
-  s.add_development_dependency 'rb-fsevent'
-  s.add_development_dependency 'growl'
   s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'aruba'
+  s.add_development_dependency 'coveralls'
 end
 

data/spec/rpub/book_spec.rb

@@ -1,115 +1,115 @@
-require 'spec_helper'
-
 describe Rpub::Book do
-  let(:subject) { described_class.new('some_file', 'title' => 'My "Awesome" Title!', 'version' => '1.0.3') }
-
-  it 'should start with an empty configuration' do
-    described_class.new('some_file').config.should == {}
-  end
-
-  it             { should respond_to(:title) }
-  its(:title)    { should == 'My "Awesome" Title!' }
-  its(:filename) { should == 'my-awesome-title-1.0.3.epub' }
+  let(:context) { Rpub::Context.new }
+  let(:subject) { described_class.new(context) }
+  before        { allow(context).to receive(:chapter_files).and_return(['foo']) }
+  it            { is_expected.to respond_to(:config) }
 
   describe 'chapters' do
-    before { subject.add_chapter 'foo' }
-
-    it { should have(1).chapters }
+    it 'has 1 chapter' do
+      expect(subject.chapters.size).to eq(1)
+    end
 
-    it { should be_kind_of(Enumerable) }
+    it { is_expected.to be_kind_of(Enumerable) }
 
-    it 'should start with no chapters' do
-      described_class.new('foo').should have(0).chapters
+    it 'should start with context chapters' do
+      expect(subject.chapters.size).to eq(1)
     end
 
     it 'should allow chaining multiple calls' do
       subject << 'foo' << 'bar'
-      subject.should have(3).chapters
+      expect(subject.chapters.size).to eq(3)
     end
 
     it 'should yield chapters' do
       yielded = false
       subject.each { |c| yielded = true }
-      yielded.should be_true
+      expect(yielded).to be_truthy
     end
   end
 
   describe '#has_fonts?' do
     it 'should not have a font by default' do
-      described_class.new(nil, {}).should_not have_fonts
-    end
-
-    it 'should not have a font with an empty array' do
-      described_class.new(nil, nil, []).should_not have_fonts
+      expect(context).to receive(:fonts).and_return([])
+      is_expected.not_to have_fonts
     end
 
     it 'should have a font with a non-empty array' do
-      described_class.new(nil, nil, ['foo']).should have_fonts
+      expect(context).to receive(:fonts).and_return(['foo'])
+      is_expected.to have_fonts
     end
   end
 
   describe '#uid' do
     it 'should change when chapters change' do
-      Rpub::Book.new('bar').add_chapter('foo').should_not == subject.uid
+      expect(described_class.new(context).add_chapter('foo')).to_not eql(subject.uid)
     end
 
     it 'should change when config changes' do
-      Rpub::Book.new('bar', 'baz' => 'qux').should_not == subject.uid
+      expect(described_class.new(context)).to_not eql(subject.uid)
     end
   end
 
   describe '#outline' do
+    before { expect(context).to receive(:chapter_files).and_return([]) }
+
     it 'should return empty array when there are no chapters' do
-      subject.outline.should be_empty
+      expect(subject.outline).to be_empty
     end
 
     it 'should return combination of all chapter outlines with filename' do
       subject << '# foo' << '# bar'
-      subject.outline.should have(2).elements
+      expect(subject.outline.size).to eq(2)
+    end
+
+    it 'should combine chapter outlines' do
+      subject << '# foo' << '# bar'
+      expect(subject.outline.first[0]).to eql('chapter-0-foo.html')
+      expect(subject.outline.first[1][0].text).to eql('foo')
     end
   end
 
   describe '#has_cover?' do
     it 'should not have a cover without a config key' do
-      described_class.new(nil, {}).should_not have_cover
+      is_expected.not_to have_cover
     end
 
     it 'should not have a cover with a config key that is false' do
-      described_class.new(nil, { 'cover_image' => false }).should_not have_cover
+      expect(context).to receive(:config).and_return(OpenStruct.new({ 'cover_image' => false }))
+      is_expected.not_to have_cover
     end
 
     it 'should have a cover with a config key' do
-      described_class.new(nil, { 'cover_image' => true}).should have_cover
+      expect(context).to receive(:config).and_return(OpenStruct.new({ 'cover_image' => true }))
+      is_expected.to have_cover
     end
   end
 
   describe '#has_toc?' do
     it 'should not have a toc without a config key' do
-      described_class.new(nil, {}).should_not have_toc
+      expect(context).to receive(:config).and_return(OpenStruct.new)
+      is_expected.not_to have_toc
     end
 
     it 'should not have a toc with a config key that is false' do
-      described_class.new(nil, { 'toc' => false }).should_not have_toc
+      expect(context).to receive(:config).and_return(OpenStruct.new({ 'toc' => false }))
+      is_expected.not_to have_toc
     end
 
     it 'should have a toc with a config key' do
-      described_class.new(nil, { 'toc' => true }).should have_toc
+      expect(context).to receive(:config).and_return(OpenStruct.new({ 'toc' => true }))
+      is_expected.to have_toc
     end
   end
 
   describe '#images' do
     before { subject << '![foo](bar)' << '![baz](qux)' << '![bla](qux)' }
-    it { should have(2).images }
-    its(:images) { should include('bar') }
-    its(:images) { should include('qux') }
-  end
 
-  describe '#outline' do
-    before { subject << '# foo' << '## bar' }
-    its(:outline) { should have(2).elements }
-    it 'should combine chapter outlines' do
-      subject.outline.first[0].should == 'chapter-0-foo.html'
-      subject.outline.first[1][0].text.should == 'foo'
+    it 'has 2 images' do
+      expect(subject.images.size).to eq(2)
+    end
+
+    it 'has includes each unique image' do
+      expect(subject.images).to include('bar', 'qux')
     end
   end
 end