epuber 0.3.5

data/lib/epuber/compiler/file_types/stylus_file.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'stylus'
+
+
+module Epuber
+  class Compiler
+    module FileTypes
+      require_relative 'source_file'
+
+      class StylusFile < SourceFile
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        def process(compilation_context)
+          write_compiled(Stylus.compile(File.new(abs_source_path)))
+        end
+      end
+    end
+  end
+end

data/lib/epuber/compiler/file_types/xhtml_file.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+
+module Epuber
+  class Compiler
+    require_relative '../xhtml_processor'
+
+    module FileTypes
+      require_relative 'source_file'
+
+      class XHTMLFile < SourceFile
+
+        # @return [Epuber::Book::TocItem]
+        #
+        attr_accessor :toc_item
+
+        # @param [Book::Target] target
+        # @param [FileResolver] file_resolver
+        #
+        # @return [Array<String>] list of paths to styles relative to this file
+        #
+        def default_styles(target, file_resolver)
+          default_styles = target.default_styles.map do |default_style_request|
+            Array(file_resolver.file_from_request(default_style_request))
+          end.flatten
+
+          default_styles.map do |style|
+            Pathname.new(style.final_destination_path).relative_path_from(Pathname.new(File.dirname(final_destination_path))).to_s
+          end
+        end
+
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        def load_source(compilation_context)
+          xhtml_content = File.read(abs_source_path)
+
+          compilation_context.perform_plugin_things(Transformer, :source_text_file) do |transformer|
+            xhtml_content = transformer.call(abs_source_path, xhtml_content, compilation_context)
+          end
+          
+          # perform custom validation
+          if compilation_context.should_check
+            compilation_context.perform_plugin_things(Checker, :source_text_file) do |checker|
+              checker.call(abs_source_path, xhtml_content, compilation_context)
+            end
+          end
+
+
+          if compilation_context.should_write
+            self.class.write_to_file(xhtml_content, abs_source_path)
+          end
+
+          xhtml_content
+        end
+
+        # @param [String] content xhtml in string
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        # @return [String] new xhtml string
+        #
+        def common_process(content, compilation_context)
+          target = compilation_context.target
+          book = compilation_context.book
+          file_resolver = compilation_context.file_resolver
+
+          xhtml_doc = XHTMLProcessor.xml_document_from_string(content, source_path)
+          XHTMLProcessor.add_missing_root_elements(xhtml_doc, book.title, target.epub_version)
+
+          XHTMLProcessor.add_styles(xhtml_doc, default_styles(target, file_resolver))
+
+          XHTMLProcessor.add_viewport(xhtml_doc, target.default_viewport) unless target.default_viewport.nil?
+          self.properties << :scripted if XHTMLProcessor.using_javascript?(xhtml_doc)
+
+          XHTMLProcessor.resolve_links(xhtml_doc, destination_path, file_resolver.dest_finder)
+          XHTMLProcessor.resolve_images(xhtml_doc, destination_path, file_resolver)
+
+          xhtml_string = xhtml_doc.to_s
+
+          # perform transformations
+          compilation_context.perform_plugin_things(Transformer, :result_text_xhtml_string) do |transformer|
+            xhtml_string = transformer.call(final_destination_path, xhtml_string, compilation_context)
+          end
+
+          # perform custom validation
+          if compilation_context.should_check
+            compilation_context.perform_plugin_things(Checker, :result_text_xhtml_string) do |checker|
+              checker.call(final_destination_path, xhtml_string, compilation_context)
+            end
+          end
+
+          xhtml_string
+        end
+
+        # @param [Compiler::CompilationContext]
+        #
+        def process(compilation_context)
+          write_processed(common_process(load_source(compilation_context), compilation_context))
+        end
+      end
+    end
+  end
+end

data/lib/epuber/compiler/generator.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'nokogiri'
+
+module Nokogiri
+  module XML
+    class Builder
+      class NodeBuilder
+        attr_reader :node
+      end
+    end
+  end
+end
+
+
+module Epuber
+  class Compiler
+    class Generator
+      # @return [Epuber::Compiler::CompilationContext]
+      #
+      attr_reader :compilation_context
+
+      # @param [Epuber::Compiler::CompilationContext] compilation_context
+      #
+      def initialize(compilation_context)
+        @compilation_context = compilation_context
+        @book = compilation_context.book
+        @target = compilation_context.target
+        @file_resolver = compilation_context.file_resolver
+      end
+
+      protected
+
+      def pretty_path_for_toc_item(toc_item, fragment: true)
+        file = @file_resolver.file_from_request(toc_item.file_request)
+        [file.destination_path, fragment ? toc_item.file_fragment : nil].compact.join('#')
+      end
+
+      # @param [Epuber::Compiler::FileTypes::AbstractFile] file
+      #
+      # @return [String]
+      #
+      def pretty_path(file)
+        file.destination_path
+      end
+
+      # Helper function for generating XML
+      #
+      # @yields xml_builder
+      # @yieldsparam [Nokogiri::XML::Builder] xml_builder
+      #
+      # @return [Nokogiri::XML::Document]
+      #
+      def generate_xml(&block)
+        builder = Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+          @xml = xml
+
+          block.call(xml) unless block.nil?
+
+          @xml = nil
+        end
+
+        builder.doc
+      end
+    end
+  end
+end

data/lib/epuber/compiler/meta_inf_generator.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'mime-types'
+
+require_relative 'generator'
+require_relative '../book/file_request'
+
+
+module Epuber
+  class Compiler
+    class MetaInfGenerator < Generator
+      # @return [Nokogiri::XML::Document]
+      #
+      def generate_container_xml
+        generate_xml do |xml|
+          xml.container(version: 1.0, xmlns: 'urn:oasis:names:tc:opendocument:xmlns:container') do
+            xml.rootfiles do
+              @file_resolver.package_files.select { |file| file.kind_of?(FileTypes::OPFFile) }.each do |file|
+                path = file.pkg_destination_path
+                xml.rootfile('full-path' => path, 'media-type' => MIME::Types.of(path).first.content_type)
+              end
+            end
+          end
+        end
+      end
+
+      # @return nil
+      #
+      def generate_ibooks_display_options_xml
+        generate_xml do |xml|
+          xml.display_options do
+            xml.platform(name: '*') do
+              xml.option(true.to_s, name: 'specified-fonts') if @target.custom_fonts
+              xml.option(true.to_s, name: 'fixed-layout') if @target.fixed_layout
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/epuber/compiler/nav_generator.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+require_relative '../book/toc_item'
+
+
+module Epuber
+  class Compiler
+    require_relative 'file_resolver'
+    require_relative 'generator'
+
+    class NavGenerator < Generator
+
+      NCX_NAMESPACES = {
+        'xmlns' => 'http://www.daisy.org/z3986/2005/ncx/',
+      }.freeze
+
+      XHTML_NAMESPACES = {
+        'xmlns' => 'http://www.w3.org/1999/xhtml',
+        'xmlns:epub' => 'http://www.idpf.org/2007/ops',
+      }.freeze
+
+      XHTML_IBOOKS_NAMESPACES = {
+        'xmlns:ibooks' => 'http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0',
+        'epub:prefix' => 'ibooks: http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0',
+      }.freeze
+
+      # resource page http://www.idpf.org/epub/301/spec/epub-contentdocs.html#sec-xhtml-nav-def-types-landmarks
+      LANDMARKS_MAP = {
+        landmark_cover:      { type: 'cover', text: 'Cover page' },
+        landmark_start_page: { type: %w(bodymatter ibooks:reader-start-page), text: 'Start Reading' },
+        landmark_copyright:  { type: 'copyright-page', text: 'Copyright page' },
+        landmark_toc:        { type: 'toc', text: 'Table of contents' },
+      }.freeze
+
+      # Generates XML for toc document, the structure differs depend on epub_version
+      #
+      # Use method #to_s to generate nice string from XML document
+      #
+      # @return [Nokogiri::XML::Document]
+      #
+      def generate_nav
+        generate_xml do
+          if @target.epub_version >= 3
+            generate_xhtml_content
+          else
+            generate_ncx_content
+          end
+        end
+      end
+
+
+      private
+
+      # @return [Hash<String, String>]
+      #
+      def nav_namespaces
+        if @target.epub_version >= 3
+          dict = XHTML_NAMESPACES
+          dict = dict.merge(XHTML_IBOOKS_NAMESPACES) if @target.ibooks?
+          dict
+        else
+          NCX_NAMESPACES
+        end
+      end
+
+      # @return nil
+      #
+      def generate_xhtml_content
+        @xml.doc.create_internal_subset('html', nil, nil)
+        @xml.html(nav_namespaces) do
+          @xml.head do
+            @xml.title_(@book.title)
+          end
+          @xml.body do
+            # toc
+            @xml.nav('epub:type' => 'toc') do
+              visit_toc_items(@target.root_toc.sub_items)
+            end
+
+            # landmarks
+            @xml.nav('epub:type' => 'landmarks') do
+              @xml.ol do
+                landmarks_visit_toc_item(@target.root_toc)
+              end
+            end
+          end
+        end
+      end
+
+      def generate_ncx_content
+        @xml.doc.create_internal_subset('ncx',
+                                        '-//NISO//DTD ncx 2005-1//EN',
+                                        'http://www.daisy.org/z3986/2005/ncx-2005-1.dtd')
+
+        @xml.ncx(nav_namespaces, version: '2005-1') do
+          # head
+          @xml.head do
+            @xml.meta(name: 'dtb:uid', content: (@target.identifier || "urn:isbn:#{@target.isbn}"))
+          end
+
+          # title
+          @xml.docTitle do
+            @xml.text_(@book.title)
+          end
+
+          @nav_nav_point_id = 1
+
+          # nav map
+          @xml.navMap do
+            visit_toc_items(@target.root_toc.sub_items)
+          end
+        end
+      end
+
+      # @param toc_items [Array<Epuber::Book::TocItem>]
+      #
+      def visit_toc_items(toc_items)
+        iterate_lambda = lambda do
+          toc_items.each do |child_item|
+            visit_toc_item(child_item)
+          end
+        end
+
+        if @target.epub_version >= 3 && toc_items.length > 0
+          @xml.ol do
+            iterate_lambda.call
+          end
+        else
+          iterate_lambda.call
+        end
+      end
+
+      # @param toc_item [Epuber::Book::TocItem]
+      #
+      def visit_toc_item(toc_item)
+        result_file_path = pretty_path_for_toc_item(toc_item)
+
+        if toc_item.title.nil?
+          visit_toc_items(toc_item.sub_items)
+        elsif @target.epub_version >= 3
+          @xml.li do
+            node_builder = @xml.a(href: result_file_path)
+            node_builder.node.inner_html = toc_item.title
+
+            visit_toc_items(toc_item.sub_items)
+          end
+        else
+          @xml.navPoint(id: "navPoint_#{@nav_nav_point_id}") do
+            @xml.navLabel do
+              node_builder = @xml.text_
+              node_builder.node.inner_html = toc_item.title
+            end
+            @xml.content(src: result_file_path)
+
+            @nav_nav_point_id += 1
+
+            visit_toc_items(toc_item.sub_items)
+          end
+        end
+      end
+
+
+      # --------------- landmarks -----------------------------
+
+      # @param toc_items [Array<Epuber::Book::TocItem>]
+      #
+      def landmarks_visit_toc_items(toc_items)
+        toc_items.each do |child_item|
+          landmarks_visit_toc_item(child_item)
+        end
+      end
+
+      # @param toc_item [Epuber::Book::TocItem]
+      #
+      def landmarks_visit_toc_item(toc_item)
+        landmarks = toc_item.landmarks
+        landmarks.each do |landmark|
+          dict = LANDMARKS_MAP[landmark]
+
+          raise "Unknown landmark `#{landmark.inspect}`, supported are #{LANDMARKS_MAP.keys}" if dict.nil?
+
+          types = Array(dict[:type])
+
+
+          # filter out ibooks specific when the target is not ibooks
+          types = types.reject { |type| type.to_s.start_with?('ibooks:') } unless @target.ibooks?
+
+          result_file_path = pretty_path_for_toc_item(toc_item, fragment: false)
+
+          types.each do |type|
+            @xml.li do
+              @xml.a(dict[:text], 'epub:type' => type, 'href' => result_file_path)
+            end
+          end
+        end
+
+        landmarks_visit_toc_items(toc_item.sub_items)
+      end
+    end
+  end
+end

data/lib/epuber/compiler/opf_generator.rb

@@ -0,0 +1,284 @@
+# encoding: utf-8
+
+require 'time'
+
+require 'mime-types'
+
+require_relative 'generator'
+require_relative '../book/toc_item'
+
+
+module Epuber
+  class Compiler
+    class OPFGenerator < Generator
+
+      EPUB2_NAMESPACES = {
+        'xmlns'     => 'http://www.idpf.org/2007/opf',
+        'xmlns:dc'  => 'http://purl.org/dc/elements/1.1/',
+        'xmlns:opf' => 'http://www.idpf.org/2007/opf',
+      }.freeze
+
+      EPUB3_NAMESPACES = {
+        'prefix'     => 'rendition: http://www.idpf.org/vocab/rendition/',
+        'xmlns:epub' => 'http://www.idpf.org/2007/ops',
+      }.freeze
+
+      IBOOKS_NAMESPACES = {
+        'prefix'       => 'rendition: http://www.idpf.org/vocab/rendition/# ibooks: http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0/',
+        'xmlns:ibooks' => 'http://apple.com/ibooks/html-extensions',
+      }.freeze
+
+      # resource page http://www.idpf.org/epub/20/spec/OPF_2.0.1_draft.htm#TOC2.6
+      LANDMARKS_MAP = {
+
+        # my favorite
+        landmark_cover:      'cover',
+        landmark_start_page: 'text',
+        landmark_copyright:  'copyright-page',
+        landmark_toc:        'toc',
+
+        # others
+        landmark_title:                 'title-page',
+        landmark_index:                 'index',
+        landmark_glossary:              'glossary',
+        landmark_acknowledgements:      'acknowledgements',
+        landmark_bibliography:          'bibliography',
+        landmark_colophon:              'colophon',
+        landmark_dedication:            'dedication',
+        landmark_epigraph:              'epigraph',
+        landmark_foreword:              'foreword',
+        landmark_list_of_illustrations: 'loi',
+        landmark_list_of_tables:        'lot',
+        landmark_notes:                 'notes',
+        landmark_preface:               'preface',
+
+      }.freeze
+
+      PROPERTIES_MAP = {
+        cover_image: 'cover-image',
+        navigation:  'nav',
+        scripted:    'scripted',
+      }.freeze
+
+      OPF_UNIQUE_ID = 'bookid'
+
+      # Generates XML for opf document
+      #
+      # Use method #to_s to generate nice string from XML document
+      #
+      # @return [Nokogiri::XML::Document]
+      #
+      def generate_opf
+        generate_xml do |xml|
+          xml.package(package_namespaces, :version => @target.epub_version, 'unique-identifier' => OPF_UNIQUE_ID) do
+            generate_metadata
+            generate_manifest
+            generate_spine
+            generate_guide
+          end
+        end
+      end
+
+      private
+
+      # --------- METADATA --------------------------
+
+      # @return nil
+      #
+      def generate_metadata
+        epub_version = @target.epub_version
+
+        @xml.metadata do
+          # identifier
+          identifier = @target.identifier || "urn:isbn:#{@target.isbn}"
+          @xml['dc'].identifier(identifier, id: OPF_UNIQUE_ID)
+
+          # title
+          if @book.title
+            if epub_version >= 3
+              @xml['dc'].title(@book.title, id: 'title')
+              @xml.meta('main', refines: '#title', property: 'title-type')
+            else
+              @xml['dc'].title(@book.title)
+            end
+          end
+
+          # authors
+          authors = @book.authors || []
+          authors.each_with_index do |author, idx|
+            author_id     = "author_#{idx + 1}"
+            author_id_ref = "##{author_id}"
+
+            if epub_version >= 3
+              @xml['dc'].creator(author.pretty_name, id: author_id)
+              @xml.meta(author.file_as, property: 'file-as', refines: author_id_ref)
+              @xml.meta(author.role, property: 'role', refines: author_id_ref, scheme: 'marc:relators')
+            else
+              @xml['dc'].creator(author.pretty_name, 'opf:file-as' => author.file_as, 'opf:role' => author.role)
+            end
+          end
+
+          @xml['dc'].publisher(@book.publisher) unless @book.publisher.nil?
+          @xml['dc'].language(@book.language) unless @book.language.nil?
+          @xml['dc'].date(@book.published.iso8601) unless @book.published.nil?
+
+          cover_image = @target.cover_image
+          unless cover_image.nil?
+            cover_image_result = @file_resolver.file_from_request(cover_image)
+            @xml.meta(name: 'cover', content: create_id_from_path(pretty_path(cover_image_result)))
+          end
+
+          if epub_version >= 3
+            @xml.meta(Time.now.utc.iso8601, property: 'dcterms:modified')
+
+            if @target.fixed_layout
+              @xml.meta('pre-paginated', property: 'rendition:layout')
+              @xml.meta('auto', property: 'rendition:orientation')
+              @xml.meta('auto', property: 'rendition:spread')
+            end
+
+            if @target.ibooks?
+              @xml.meta(@book.version, property: 'ibooks:version') unless @book.version.nil?
+              @xml.meta(@target.custom_fonts, property: 'ibooks:specified-fonts') unless @target.custom_fonts.nil?
+            end
+          end
+
+          @xml.meta(name: 'Created by', content: Epuber.to_s)
+          @xml.meta(name: 'Epuber version', content: Epuber::VERSION)
+        end
+      end
+
+      # --------- MANIFEST --------------------------
+
+      # @return nil
+      #
+      def generate_manifest
+        @xml.manifest do
+          @file_resolver.manifest_files.each do |file|
+            pretty_path         = pretty_path(file)
+            attrs               = {}
+            attrs['id']         = create_id_from_path(pretty_path)
+            attrs['href']       = pretty_path
+            attrs['media-type'] = mime_type_for(file)
+
+            properties = file.properties
+            if properties.length > 0 && @target.epub_version >= 3
+              pretty_properties = properties.to_a.map { |property| PROPERTIES_MAP[property] }.join(' ')
+              attrs['properties'] = pretty_properties
+            end
+
+            @xml.item(attrs)
+          end
+        end
+      end
+
+      # --------- SPINE --------------------------
+
+      # @return nil
+      #
+      def generate_spine
+        args = if @target.epub_version >= 3
+                 {}
+               else
+                 nav_file = @file_resolver.manifest_files.find { |file| file.destination_path.end_with?('.ncx') }
+                 raise 'not found nav file' if nav_file.nil?
+
+                 { toc: create_id_from_path(pretty_path(nav_file)) }
+               end
+
+        all_items = @target.root_toc.flat_sub_items.map do |toc_item|
+          result_file = @file_resolver.file_from_request(toc_item.file_request)
+
+          attrs = {}
+          attrs['idref'] = create_id_from_path(pretty_path(result_file))
+          attrs['linear'] = 'no' unless toc_item.linear?
+
+          attrs
+        end
+
+        # uniq, but without any other attributes
+        all_items.uniq! { |i| i['idref'] }
+
+        @xml.spine(args) do
+          all_items.each do |attrs|
+            @xml.itemref(attrs)
+          end
+        end
+      end
+
+      # --------- GUIDE --------------------------
+
+      def generate_guide
+        return if @target.epub_version >= 3
+
+        @xml.guide do
+          guide_visit_toc_item(@target.root_toc)
+        end
+      end
+
+      # @param toc_items [Array<Epuber::Book::TocItem>]
+      #
+      # @return nil
+      #
+      def guide_visit_toc_items(toc_items)
+        toc_items.each do |child_item|
+          guide_visit_toc_item(child_item)
+        end
+      end
+
+      # @param toc_item [Epuber::Book::TocItem]
+      #
+      # @return nil
+      #
+      def guide_visit_toc_item(toc_item)
+        unless toc_item.file_request.nil?
+          result_file = @file_resolver.file_from_request(toc_item.file_request)
+
+          toc_item.landmarks.each do |landmark|
+            type = LANDMARKS_MAP[landmark]
+
+            raise "Unknown landmark `#{landmark.inspect}`, supported are #{LANDMARKS_MAP.keys}" if type.nil?
+
+            @xml.reference(type: type, href: pretty_path(result_file))
+          end
+        end
+
+        guide_visit_toc_items(toc_item.sub_items)
+      end
+
+      # --------- other methods --------------------------
+
+      # Creates id from file path
+      #
+      # @param path [String]
+      #
+      # @return [String]
+      #
+      def create_id_from_path(path)
+        path && path.gsub('/', '.')
+      end
+
+      # Creates proper mime-type for file
+      #
+      # @param file [Epuber::Book::File]
+      #
+      # @return [String]
+      #
+      def mime_type_for(file)
+        filename = file.destination_path
+        MIME::Types.of(filename).first.content_type
+      end
+
+      # Creates hash of namespaces for root package element
+      #
+      # @return [Hash<String, String>]
+      #
+      def package_namespaces
+        namespaces = [EPUB2_NAMESPACES]
+        namespaces << EPUB3_NAMESPACES if @target.epub_version >= 3
+        namespaces << IBOOKS_NAMESPACES if @target.epub_version >= 3 && @target.ibooks?
+        namespaces.reduce(:merge)
+      end
+    end
+  end
+end